Fractal Block World

Environment Variables


This documentation was created for the following version of the program: 1.01.29
One can toggle the console (while in game) by pressing the '~' key.

Commands can be entered while in the console. For example, entering the command "exit" will cause the program to exit.

The game has "environment variables" that can be accessed through the console. The "get" command prints the value of the specified environment variable.

The "ls" command lists all variables that start with a given prefix. Note: in addition to environment variables, there are "directories" which are simply a prefix of an environment variable name that ends with a period. The ls command lists variables and directories with the given prefix.

Variables can be changed using the "set" command, assuming you have access to do so. Note that all access is granted by enabling cheat codes.

Environment variables are important because you can set them in the "program_startup" script that is run when the program starts up. You can use this for advanced customization.

This document contains a dump of all environment variables.

This document was created by running the program and calling the "gendoc" console command.

Green entries represent directories, whereas gray ones represent individual environment variables. Some variables or directories are documented with blue text.


package (dir)

package.state (dir)

package.state.input (dir)

package.state.input.binds (dir)

package.state.input.binds.SEMICOLON (dir)

package.state.input.binds.SEMICOLON.downup (string)

package.state.input.binds.RSHIFT (dir)

package.state.input.binds.RSHIFT.downup (string)

package.state.input.binds.RCTRL (dir)

package.state.input.binds.RCTRL.downup (string)

package.state.input.binds.RALT (dir)

package.state.input.binds.RALT.downup (string)

package.state.input.binds.QUOTE (dir)

package.state.input.binds.QUOTE.downup (string)

package.state.input.binds.MOUSE5 (dir)

package.state.input.binds.MOUSE5.downup (string)

package.state.input.binds.MOUSE4 (dir)

package.state.input.binds.MOUSE4.downup (string)

package.state.input.binds.MOUSE3 (dir)

package.state.input.binds.MOUSE3.downup (string)

package.state.input.binds.LEFT (dir)

package.state.input.binds.LEFT.downup (string)

package.state.input.binds.UP (dir)

package.state.input.binds.UP.downup (string)

package.state.input.binds.LALT (dir)

package.state.input.binds.LALT.downup (string)

package.state.input.binds.HOME (dir)

package.state.input.binds.HOME.downup (string)

package.state.input.binds.EQUALS (dir)

package.state.input.binds.EQUALS.downup (string)

package.state.input.binds.COMMA (dir)

package.state.input.binds.COMMA.downup (string)

package.state.input.binds.MOUSEWHEEL_UP (dir)

package.state.input.binds.MOUSEWHEEL_UP.use (string)

package.state.input.binds.MOUSE2 (dir)

package.state.input.binds.MOUSE2.downup (string)

package.state.input.binds.BACKSPACE (dir)

package.state.input.binds.BACKSPACE.downup (string)

package.state.input.binds.SLASH (dir)

package.state.input.binds.SLASH.downup (string)

package.state.input.binds.F12 (dir)

package.state.input.binds.F12.downup (string)

package.state.input.binds.F11 (dir)

package.state.input.binds.F11.downup (string)

package.state.input.binds.F10 (dir)

package.state.input.binds.F10.downup (string)

package.state.input.binds.F8 (dir)

package.state.input.binds.F8.downup (string)

package.state.input.binds.F7 (dir)

package.state.input.binds.F7.downup (string)

package.state.input.binds.MINUS (dir)

package.state.input.binds.MINUS.downup (string)

package.state.input.binds.F6 (dir)

package.state.input.binds.F6.downup (string)

package.state.input.binds.RIGHT (dir)

package.state.input.binds.RIGHT.downup (string)

package.state.input.binds.S (dir)

package.state.input.binds.S.downup (string)

package.state.input.binds.LCTRL (dir)

package.state.input.binds.LCTRL.downup (string)

package.state.input.binds.Q (dir)

package.state.input.binds.Q.downup (string)

package.state.input.binds.P (dir)

package.state.input.binds.P.downup (string)

package.state.input.binds.O (dir)

package.state.input.binds.O.downup (string)

package.state.input.binds.V (dir)

package.state.input.binds.V.downup (string)

package.state.input.binds.SPACE (dir)

package.state.input.binds.SPACE.downup (string)

package.state.input.binds.N (dir)

package.state.input.binds.N.downup (string)

package.state.input.binds.RBRACKET (dir)

package.state.input.binds.RBRACKET.downup (string)

package.state.input.binds.E (dir)

package.state.input.binds.E.downup (string)

package.state.input.binds.U (dir)

package.state.input.binds.U.downup (string)

package.state.input.binds.G (dir)

package.state.input.binds.G.downup (string)

package.state.input.binds.7 (dir)

package.state.input.binds.7.downup (string)

package.state.input.binds.D (dir)

package.state.input.binds.D.downup (string)

package.state.input.binds.L (dir)

package.state.input.binds.L.downup (string)

package.state.input.binds.F (dir)

package.state.input.binds.F.downup (string)

package.state.input.binds.A (dir)

package.state.input.binds.A.downup (string)

package.state.input.binds.B (dir)

package.state.input.binds.B.downup (string)

package.state.input.binds.TAB (dir)

package.state.input.binds.TAB.downup (string)

package.state.input.binds.M (dir)

package.state.input.binds.M.downup (string)

package.state.input.binds.K (dir)

package.state.input.binds.K.downup (string)

package.state.input.binds.H (dir)

package.state.input.binds.H.downup (string)

package.state.input.binds.ENTER (dir)

package.state.input.binds.ENTER.downup (string)

package.state.input.binds.X (dir)

package.state.input.binds.X.downup (string)

package.state.input.binds.Y (dir)

package.state.input.binds.Y.downup (string)

package.state.input.binds.I (dir)

package.state.input.binds.I.downup (string)

package.state.input.binds.W (dir)

package.state.input.binds.W.downup (string)

package.state.input.binds.6 (dir)

package.state.input.binds.6.downup (string)

package.state.input.binds.F9 (dir)

package.state.input.binds.F9.downup (string)

package.state.input.binds.R (dir)

package.state.input.binds.R.downup (string)

package.state.input.binds.J (dir)

package.state.input.binds.J.downup (string)

package.state.input.binds.Z (dir)

package.state.input.binds.Z.downup (string)

package.state.input.binds.MOUSE1 (dir)

package.state.input.binds.MOUSE1.downup (string)

package.state.input.binds.1 (dir)

package.state.input.binds.1.downup (string)

package.state.input.binds.2 (dir)

package.state.input.binds.2.downup (string)

package.state.input.binds.LBRACKET (dir)

package.state.input.binds.LBRACKET.downup (string)

package.state.input.binds.END (dir)

package.state.input.binds.END.downup (string)

package.state.input.binds.DOWN (dir)

package.state.input.binds.DOWN.downup (string)

package.state.input.binds.4 (dir)

package.state.input.binds.4.downup (string)

package.state.input.binds.PERIOD (dir)

package.state.input.binds.PERIOD.downup (string)

package.state.input.binds.8 (dir)

package.state.input.binds.8.downup (string)

package.state.input.binds.0 (dir)

package.state.input.binds.0.downup (string)

package.state.input.binds.GRAVE (dir)

package.state.input.binds.GRAVE.downup (string)

package.state.input.binds.5 (dir)

package.state.input.binds.5.downup (string)

package.state.input.binds.DELETE (dir)

package.state.input.binds.DELETE.downup (string)

package.state.input.binds.BACKSLASH (dir)

package.state.input.binds.BACKSLASH.downup (string)

package.state.input.binds.F1 (dir)

package.state.input.binds.F1.downup (string)

package.state.input.binds.9 (dir)

package.state.input.binds.9.downup (string)

package.state.input.binds.C (dir)

package.state.input.binds.C.downup (string)

package.state.input.binds.ESC (dir)

package.state.input.binds.ESC.downup (string)

package.state.input.binds.T (dir)

package.state.input.binds.T.downup (string)

package.state.input.binds.LSHIFT (dir)

package.state.input.binds.LSHIFT.downup (string)

package.state.input.binds.F2 (dir)

package.state.input.binds.F2.downup (string)

package.state.input.binds.MOUSEWHEEL_DOWN (dir)

package.state.input.binds.MOUSEWHEEL_DOWN.use (string)

package.state.input.binds.F5 (dir)

package.state.input.binds.F5.downup (string)

package.state.input.binds.3 (dir)

package.state.input.binds.3.downup (string)

package.state.input.binds.F3 (dir)

package.state.input.binds.F3.downup (string)

package.state.input.binds.F4 (dir)

package.state.input.binds.F4.downup (string)

package.state.mods (dir)

package.state.mods.selected (string)

package.state.globals (dir)

package.state.globals.sound (dir)

package.state.globals.sound.player_hurt_sounds_enabled (bool)

package.state.globals.render (dir)

package.state.globals.render.levels_fade_out_local (bool)

package.state.globals.render.levels_fade_out_local (bool)

package.state.globals.render.levels_fade_out_local.enabled (bool)

package.state.globals.render.levels_fade_out_local.min_level_shade (float)

package.state.globals.render.levels_fade_out_local.max_level_shade (float)

package.state.globals.movement (dir)

package.state.globals.movement.black_hole_drive (dir)

package.state.globals.movement.black_hole_drive.uses_alt_radius (bool)

package.state.globals.movement.black_hole_drive.alt_radius (int)

package.state.globals.movement.roll (dir)

package.state.globals.movement.roll.drag (float)

package.state.globals.movement.roll.acc (float)

package.state.globals.movement.quasar_drive (dir)

package.state.globals.movement.quasar_drive.uses_alt_radius (bool)

package.state.globals.movement.quasar_drive.alt_radius (int)

package.state.globals.flashes (dir)

package.state.globals.flashes.enable (bool)

package.state.globals.inf2 (dir)

package.state.globals.inf2.can_build_block_into_player (bool)

menu (dir)

menu.render_world_behind (bool)
If true, then when in a main menu, the world will be rendered behind the menu. Note: if the frame rate is too low, the world will NOT be rendered behind the menu.

menu.last_player_name (string)
The player name associated to the last game that was played. This is useful because when the user loads a game, the user will probably want to select this name.

menu.was_in_menu (bool)
True iff last cycle the player was either in the main menu, the console, or a game menu. This is needed because once the player opens some kind of menu from normal gameplay, all the input keys must be "cleared".

menu.back_alpha (float)
The background alpha of windows in the main menu.

menu.in_main (bool)
If true, the game is paused (if there is a game loaded) and the user is in the main menu.

menu.in_package (bool)
If true, the game is paused and the user is in menu that comes with the package.

menu.basic_new_game_menu (bool)
When this is true, when the player starts a new game it will automatically be in the Xar package in the classic configuration with a random seed.

menu.ent_press_key_prompt (bool)
Whether a message appears to use an item (that can be used) when the player has their crosshair on it. This var should probably be removed.

menu.back_alpha_dark (float)
The darker background alpha of windows in the main menu. Some windows have a darker background than others.

menu.back_color (vector)
The background color of windows in the main menu.

menu.in_load_error (bool)
Whether the user is in a menu to deal with an error from loading a game. These menus are essentially popup menus.

menu.text_color (vector)
The color of text in the main menu.

menu.load_error (dir)
If there is an error loading a game, the user must deal with a popup menu. Some of these menus allow the user to resume the load while forcing the value of a var. To resume the load, we must store the params that were passed to the loading function.

menu.load_error.3 (dir)

menu.load_error.3.str (string)

menu.load_error.3.has (bool)

menu.load_error.1 (dir)

menu.load_error.1.override_eng_ver (string)

menu.load_error.1.type_new (bool)

menu.load_error.1.has (bool)

menu.load_error.1.new (dir)

menu.load_error.1.new.world_seed (int)

menu.load_error.1.new.player (string)

menu.load_error.1.new.starting_config_file (string)

menu.load_error.2 (dir)

menu.load_error.2.has (bool)

menu.load_error.2.force_expected_package_ver (string)

menu.load_error.2.force_expected_eng_ver (string)

menu.cursor (dir)

menu.cursor.use_in_windowed_mode (bool)
This specifies whether the cursor is used in windowed mode. See "menu.cursor.use_in_fullscreen_mode".

menu.cursor.use_in_fullscreen_mode (bool)
This specifies whether a cursor is used in the game's main menu while the game is in fullscreen mode. Note that during normal gameplay of the xar package, there is no cursor. Note that it is intended to not use a cursor in fullscreen mode.

menu.colorblind (dir)

menu.colorblind.enable (bool)

menu.colorblind.closest_palette (dir)

menu.colorblind.closest_palette.19 (vector)

menu.colorblind.closest_palette.17 (vector)

menu.colorblind.closest_palette.16 (vector)

menu.colorblind.closest_palette.14 (vector)

menu.colorblind.closest_palette.12 (vector)

menu.colorblind.closest_palette.20 (vector)

menu.colorblind.closest_palette.5 (vector)

menu.colorblind.closest_palette.11 (vector)

menu.colorblind.closest_palette.1 (vector)

menu.colorblind.closest_palette.4 (vector)

menu.colorblind.closest_palette.18 (vector)

menu.colorblind.closest_palette.15 (vector)

menu.colorblind.closest_palette.2 (vector)

menu.colorblind.closest_palette.3 (vector)

menu.colorblind.closest_palette.8 (vector)

menu.colorblind.closest_palette.6 (vector)

menu.colorblind.closest_palette.9 (vector)

menu.colorblind.closest_palette.13 (vector)

menu.colorblind.closest_palette.7 (vector)

menu.colorblind.closest_palette.10 (vector)

menu.load_game (dir)

menu.load_game.main_sort_by (int)
This variable remembers the way the user sorted players (by name, by last used time, etc).

menu.waypoint (dir)

menu.waypoint.hidden_sort_by (int)
See "menu.waypoint.main_sort_by".

menu.waypoint.main_sort_by (int)
Currently, the waypoint menu is hard coded into the engine. This variable remembers the way in which waypoints are sorted (by name, by last used time, etc).

metagame (dir)
Variables that start with "game" are removed just before we load a game. However, variables that start with "metagame" are not. That is, metagame vars can last longer than one loaded game. So you can set metagame.cheat.god to true, then load a different game and it will still be true.

metagame.cheat (dir)
Some cheat codes are defined by the package, and so you can enable them, save the game, exit the program, start the program again, load the game, and the cheat code will be enabled again. Other cheat codes, such as the ones here, are system cheat codes. They are not stored when the program exits. On the other hand, they are not associated to any game. So you can set metagame.cheat.god to true, load a different game, than god mode will still be on.

metagame.cheat.noclip (bool)

metagame.cheat.shrink_any (bool)

metagame.cheat.enabled (bool)

metagame.cheat.god (bool)

metagame.cheat.dev_enabled (bool)

metagame.input (dir)

metagame.input.binds (dir)
There are input events, and then there are input actions. Input events are bound to input actions. For example, metagame.input.binds.input.6.down may be set to CUSTOM_03.

metagame.input.binds.actions (dir)
There are two kinds of input actions: custom and package. Custom input actions are specified here. When an action is executed, the string will be executed as a console command. Package input actions, on the other hand, are defined by the package in the binds.txt file. All package input actions should start with "PACKAGE".

metagame.input.binds.actions.CUSTOM_40 (dir)

metagame.input.binds.actions.CUSTOM_40.secondary (string)

metagame.input.binds.actions.CUSTOM_40.nickname (string)

metagame.input.binds.actions.CUSTOM_40.primary (string)

metagame.input.binds.actions.CUSTOM_39 (dir)

metagame.input.binds.actions.CUSTOM_39.secondary (string)

metagame.input.binds.actions.CUSTOM_39.nickname (string)

metagame.input.binds.actions.CUSTOM_39.primary (string)

metagame.input.binds.actions.CUSTOM_36 (dir)

metagame.input.binds.actions.CUSTOM_36.secondary (string)

metagame.input.binds.actions.CUSTOM_36.nickname (string)

metagame.input.binds.actions.CUSTOM_36.primary (string)

metagame.input.binds.actions.CUSTOM_35 (dir)

metagame.input.binds.actions.CUSTOM_35.secondary (string)

metagame.input.binds.actions.CUSTOM_35.nickname (string)

metagame.input.binds.actions.CUSTOM_35.primary (string)

metagame.input.binds.actions.CUSTOM_34 (dir)

metagame.input.binds.actions.CUSTOM_34.secondary (string)

metagame.input.binds.actions.CUSTOM_34.nickname (string)

metagame.input.binds.actions.CUSTOM_34.primary (string)

metagame.input.binds.actions.CUSTOM_38 (dir)

metagame.input.binds.actions.CUSTOM_38.secondary (string)

metagame.input.binds.actions.CUSTOM_38.nickname (string)

metagame.input.binds.actions.CUSTOM_38.primary (string)

metagame.input.binds.actions.CUSTOM_32 (dir)

metagame.input.binds.actions.CUSTOM_32.secondary (string)

metagame.input.binds.actions.CUSTOM_32.nickname (string)

metagame.input.binds.actions.CUSTOM_32.primary (string)

metagame.input.binds.actions.CUSTOM_28 (dir)

metagame.input.binds.actions.CUSTOM_28.secondary (string)

metagame.input.binds.actions.CUSTOM_28.nickname (string)

metagame.input.binds.actions.CUSTOM_28.primary (string)

metagame.input.binds.actions.CUSTOM_27 (dir)

metagame.input.binds.actions.CUSTOM_27.secondary (string)

metagame.input.binds.actions.CUSTOM_27.nickname (string)

metagame.input.binds.actions.CUSTOM_27.primary (string)

metagame.input.binds.actions.CUSTOM_26 (dir)

metagame.input.binds.actions.CUSTOM_26.secondary (string)

metagame.input.binds.actions.CUSTOM_26.nickname (string)

metagame.input.binds.actions.CUSTOM_26.primary (string)

metagame.input.binds.actions.CUSTOM_25 (dir)

metagame.input.binds.actions.CUSTOM_25.secondary (string)

metagame.input.binds.actions.CUSTOM_25.nickname (string)

metagame.input.binds.actions.CUSTOM_25.primary (string)

metagame.input.binds.actions.CUSTOM_24 (dir)

metagame.input.binds.actions.CUSTOM_24.secondary (string)

metagame.input.binds.actions.CUSTOM_24.nickname (string)

metagame.input.binds.actions.CUSTOM_24.primary (string)

metagame.input.binds.actions.CUSTOM_11 (dir)

metagame.input.binds.actions.CUSTOM_11.secondary (string)

metagame.input.binds.actions.CUSTOM_11.nickname (string)

metagame.input.binds.actions.CUSTOM_11.primary (string)

metagame.input.binds.actions.CUSTOM_04 (dir)

metagame.input.binds.actions.CUSTOM_04.secondary (string)

metagame.input.binds.actions.CUSTOM_04.nickname (string)

metagame.input.binds.actions.CUSTOM_04.primary (string)

metagame.input.binds.actions.CUSTOM_37 (dir)

metagame.input.binds.actions.CUSTOM_37.secondary (string)

metagame.input.binds.actions.CUSTOM_37.nickname (string)

metagame.input.binds.actions.CUSTOM_37.primary (string)

metagame.input.binds.actions.CUSTOM_08 (dir)

metagame.input.binds.actions.CUSTOM_08.secondary (string)

metagame.input.binds.actions.CUSTOM_08.nickname (string)

metagame.input.binds.actions.CUSTOM_08.primary (string)

metagame.input.binds.actions.CUSTOM_06 (dir)

metagame.input.binds.actions.CUSTOM_06.secondary (string)

metagame.input.binds.actions.CUSTOM_06.nickname (string)

metagame.input.binds.actions.CUSTOM_06.primary (string)

metagame.input.binds.actions.CUSTOM_02 (dir)

metagame.input.binds.actions.CUSTOM_02.secondary (string)

metagame.input.binds.actions.CUSTOM_02.nickname (string)

metagame.input.binds.actions.CUSTOM_02.primary (string)

metagame.input.binds.actions.CUSTOM_23 (dir)

metagame.input.binds.actions.CUSTOM_23.secondary (string)

metagame.input.binds.actions.CUSTOM_23.nickname (string)

metagame.input.binds.actions.CUSTOM_23.primary (string)

metagame.input.binds.actions.CUSTOM_07 (dir)

metagame.input.binds.actions.CUSTOM_07.secondary (string)

metagame.input.binds.actions.CUSTOM_07.nickname (string)

metagame.input.binds.actions.CUSTOM_07.primary (string)

metagame.input.binds.actions.CUSTOM_10 (dir)

metagame.input.binds.actions.CUSTOM_10.secondary (string)

metagame.input.binds.actions.CUSTOM_10.nickname (string)

metagame.input.binds.actions.CUSTOM_10.primary (string)

metagame.input.binds.actions.CUSTOM_01 (dir)

metagame.input.binds.actions.CUSTOM_01.secondary (string)

metagame.input.binds.actions.CUSTOM_01.nickname (string)

metagame.input.binds.actions.CUSTOM_01.primary (string)

metagame.input.binds.actions.CUSTOM_29 (dir)

metagame.input.binds.actions.CUSTOM_29.secondary (string)

metagame.input.binds.actions.CUSTOM_29.nickname (string)

metagame.input.binds.actions.CUSTOM_29.primary (string)

metagame.input.binds.actions.CUSTOM_03 (dir)

metagame.input.binds.actions.CUSTOM_03.secondary (string)

metagame.input.binds.actions.CUSTOM_03.nickname (string)

metagame.input.binds.actions.CUSTOM_03.primary (string)

metagame.input.binds.actions.CUSTOM_16 (dir)

metagame.input.binds.actions.CUSTOM_16.secondary (string)

metagame.input.binds.actions.CUSTOM_16.nickname (string)

metagame.input.binds.actions.CUSTOM_16.primary (string)

metagame.input.binds.actions.CUSTOM_12 (dir)

metagame.input.binds.actions.CUSTOM_12.secondary (string)

metagame.input.binds.actions.CUSTOM_12.nickname (string)

metagame.input.binds.actions.CUSTOM_12.primary (string)

metagame.input.binds.actions.CUSTOM_30 (dir)

metagame.input.binds.actions.CUSTOM_30.secondary (string)

metagame.input.binds.actions.CUSTOM_30.nickname (string)

metagame.input.binds.actions.CUSTOM_30.primary (string)

metagame.input.binds.actions.CUSTOM_13 (dir)

metagame.input.binds.actions.CUSTOM_13.secondary (string)

metagame.input.binds.actions.CUSTOM_13.nickname (string)

metagame.input.binds.actions.CUSTOM_13.primary (string)

metagame.input.binds.actions.CUSTOM_31 (dir)

metagame.input.binds.actions.CUSTOM_31.secondary (string)

metagame.input.binds.actions.CUSTOM_31.nickname (string)

metagame.input.binds.actions.CUSTOM_31.primary (string)

metagame.input.binds.actions.CUSTOM_14 (dir)

metagame.input.binds.actions.CUSTOM_14.secondary (string)

metagame.input.binds.actions.CUSTOM_14.nickname (string)

metagame.input.binds.actions.CUSTOM_14.primary (string)

metagame.input.binds.actions.CUSTOM_20 (dir)

metagame.input.binds.actions.CUSTOM_20.secondary (string)

metagame.input.binds.actions.CUSTOM_20.nickname (string)

metagame.input.binds.actions.CUSTOM_20.primary (string)

metagame.input.binds.actions.CUSTOM_33 (dir)

metagame.input.binds.actions.CUSTOM_33.secondary (string)

metagame.input.binds.actions.CUSTOM_33.nickname (string)

metagame.input.binds.actions.CUSTOM_33.primary (string)

metagame.input.binds.actions.CUSTOM_05 (dir)

metagame.input.binds.actions.CUSTOM_05.secondary (string)

metagame.input.binds.actions.CUSTOM_05.nickname (string)

metagame.input.binds.actions.CUSTOM_05.primary (string)

metagame.input.binds.actions.CUSTOM_22 (dir)

metagame.input.binds.actions.CUSTOM_22.secondary (string)

metagame.input.binds.actions.CUSTOM_22.nickname (string)

metagame.input.binds.actions.CUSTOM_22.primary (string)

metagame.input.binds.actions.CUSTOM_17 (dir)

metagame.input.binds.actions.CUSTOM_17.secondary (string)

metagame.input.binds.actions.CUSTOM_17.nickname (string)

metagame.input.binds.actions.CUSTOM_17.primary (string)

metagame.input.binds.actions.CUSTOM_15 (dir)

metagame.input.binds.actions.CUSTOM_15.secondary (string)

metagame.input.binds.actions.CUSTOM_15.nickname (string)

metagame.input.binds.actions.CUSTOM_15.primary (string)

metagame.input.binds.actions.CUSTOM_09 (dir)

metagame.input.binds.actions.CUSTOM_09.secondary (string)

metagame.input.binds.actions.CUSTOM_09.nickname (string)

metagame.input.binds.actions.CUSTOM_09.primary (string)

metagame.input.binds.actions.CUSTOM_18 (dir)

metagame.input.binds.actions.CUSTOM_18.secondary (string)

metagame.input.binds.actions.CUSTOM_18.nickname (string)

metagame.input.binds.actions.CUSTOM_18.primary (string)

metagame.input.binds.actions.CUSTOM_19 (dir)

metagame.input.binds.actions.CUSTOM_19.secondary (string)

metagame.input.binds.actions.CUSTOM_19.nickname (string)

metagame.input.binds.actions.CUSTOM_19.primary (string)

metagame.input.binds.actions.CUSTOM_21 (dir)

metagame.input.binds.actions.CUSTOM_21.secondary (string)

metagame.input.binds.actions.CUSTOM_21.nickname (string)

metagame.input.binds.actions.CUSTOM_21.primary (string)

metagame.input.mouse (dir)

metagame.input.mouse.sensitivity (dir)
You can adjust the mouse sensitivity for the game (turning the player's head) and also for windows where there is a cursor. These are adjusted separately. Also, the x and y components of the sensitivity are set separately.

metagame.input.mouse.sensitivity.windows (dir)

metagame.input.mouse.sensitivity.windows.y (float)

metagame.input.mouse.sensitivity.windows.x (float)

metagame.input.mouse.sensitivity.game (dir)

metagame.input.mouse.sensitivity.game.invert_y (bool)

metagame.input.mouse.sensitivity.game.x (float)

metagame.input.mouse.sensitivity.game.y (float)

metagame.player (dir)

metagame.player.model (dir)
If 3rd person mode is enabled, these vars specify the Quake 2 character model used for the player's body. You must specify the md2 file itself (for the mesh and the animation frames) as well as the single texture associated to the mesh.

metagame.player.model.q2md2 (dir)

metagame.player.model.q2md2.tex (string)
The name of the jpg file to use for the player. For example, "Input/Q2MD2_Models/MODEL_NAME/MODEL_NAME.jpg".

metagame.player.model.q2md2.md2 (string)
The name of the md2 file to use for the player. For example, "Input/Q2MD2_Models/MODEL_NAME/MODEL_NAME.md2".

metagame.player.camera (dir)

metagame.player.camera.3rdp (dir)

metagame.player.camera.3rdp.enabled (bool)
If this is true, then instead of looking at the world from the player's perspective, we instead look at the player from slightly behind him. This is intended for games with gravity.

display (dir)

display.fullscreen (bool)
Whether or not the program is run on fullscreen or windowed mode.

display.has_inner_focus (bool)
This is true when the program's window is in focus (in the sense of the operating system) and the user has clicked in the body of the program's window. The point is when this is true, the (system) mouse cursor is hidden. Note that the user can resize the game's window (if the game is being run in windowed mode) without the cursor being hidden.

display.hud (dir)

display.hud.show_dir (bool)
Normally, when the viewer turns towards one of the 6 cardinal directions, either "UP", "DOWN", "LEFT", "RIGHT", "FRONT", or "BACK" will be displayed. However when this var is set to false, the displaying of this text is disabled.

display.hud.hide_all_huds (bool)
When this is true, the system hud (on the upper half of the screen) is not rendered, and the package defined hud windows (on the lower half of the screen) are not rendered (or updated) either. This is intended for taking a screenshot of the world.

display.hud.show_loading_graph_in_menus (bool)
Even when the player is in a menu (even the main menu), the "exploration" process continues. This is the process of creating and destroying chunks. When this var is set to true, a graph showing the progress of this process is displayed in the main menu.

display.hud.diegetic (dir)

display.hud.diegetic.scale_y (float)
The (diegetic) HUD is scaled in the y direction by this factor.

display.hud.diegetic.scale_x (float)
The (diegetic) HUD is scaled in the x direction by this factor.

display.hud.diegetic.use (bool)
When this is true, the HUD is rendered in the world as opposed on the screen on top of the world. This var should not be used by the user: it is set internally by the engine. See also display.stereoscope.use_diegetic_hud.

display.hud.diegetic.dist (float)
The distance from the camera to the plane that contains the (diegetic) HUD.

display.hud.msg (dir)
The "hud message" is what shows up in the center of the screen, above the crosshairs, to display a message to the user. There can only be one hud message at a time, and the last hud message only lasts for a certain amount of time.

display.hud.msg.color (vector)
The color of the text of the hud message.

display.hud.msg.back_alpha (float)
The alpha of the background behind the hud message.

display.hud.msg.back_color (vector)
The color of the background behind the hud message.

display.hud.side_displays (dir)
On the upper left and upper right of the screen there are displays showing things like frame rate or what level the player is on. These are called "side displays". This displays are read in from Lua files stored in Data/Packages/base/Windows/HUD/SideDisplays/ and Input/HUD/SideDisplays.

display.hud.side_displays.state (string)

display.hud.side_displays.width (float)

display.hud.side_displays.height (float)
The width of each side display. 1.0 is the distance from the left of the screen to the right.

display.hud.attack_display (dir)
The attack display shows colored circles in the center of the screen when the player is hit by enemy attacks. The location of the circle depends on where the attack came from. The size of the circle represents the damage done by the attack.

display.hud.attack_display.screen_x_stretch (float)
The factor by which to stretch the entire attack display in the x direction. Note: the screen is 1.0 wide, and 1.0 high.

display.hud.attack_display.type (string)
This var should be set to either "sphere" or "cylinder". Use the sphere type for a 6 degrees of freedom package.

display.hud.attack_display.keep_time (float)
How many seconds an attack circle stays on the screen, before it turns invisible and disappears.

display.hud.attack_display.enable (bool)
This var represents whether or not the attack display should be shown.

display.hud.attack_display.dot_radius (float)
The radius of an attack circle is proportional to this var times the damage done by the attack.

display.hud.attack_display.90_deg_radius (float)
The distance from the center of the screen attack circles are displayed which come from attacks that are 90 degrees from where the player is looking.

display.hud.attack_display.color (vector)
The color of the attack circles.

display.hud.crosshair (dir)
The crosshair texture is called "crosshair". So, you can change the crosshair texture by changing the file associated to the "crosshair" texture name in "Data/PACKAGE/Textures/texture_names.txt".

display.hud.crosshair.hide (bool)
If true, the crosshair will not be shown.

display.hud.crosshair.x_scale (float)
The size of the crosshair in the x direction is this var times display.hud.crosshair.scale.

display.hud.crosshair.color (vector)
The color to shade the crosshair texture.

display.hud.crosshair.scale (float)
The size of the crosshair, in the y direction.

display.screen (dir)

display.screen.height (int)
This is like display.screen.width, but for the height instead.

display.screen.width (int)
The current screen width in pixels.

display.stereoscope (dir)

display.stereoscope.red_on_left (bool)
If this is true, then the left eye is rendered to the red channel.

display.stereoscope.only_render_left (bool)
This is just for debugging. During stereoscopic mode, if this var is true then only the left camera is used for rendering.

display.stereoscope.dist_between_eyes (float)
The distance between the two cameras when stereoscopic rendering occurs. Note: each block is 1.0 wide.

display.stereoscope.3d_red_blue_glasses_enabled (bool)
If true, then two images will be rendered (from slightly different camera positions). One will be rendered in red, and the other in blue.

display.stereoscope.elastic_accum (float)
This is a helper variable that is used internally to update elastic_scale.

display.stereoscope.use_diegetic_hud (bool)
When the game renders in stereoscopic mode, this var specifies whether or not the HUD is diegetic (is suspended in front of the player in the world).

display.stereoscope.elastic_scale (float)
This will gradually return to the value of 1.0 when it is changed. This is used make the distance between eye change less abrupt when the player shrinks or grows.

display.stereoscope.elastic_recovery (float)
This dictates how quickly elastic_scale recovers. A high number means faster recovery. 0.1 is very fast, and 0.05 is medium speed.

display.screen_mode (dir)

display.screen_mode.pause_when_window_no_focus (bool)
When this is true, the program is paused when the window does not have the focus.

display.screen_mode.windowed (dir)

display.screen_mode.windowed.height (int)
This is like display.screen_mode.windowed.width, but for the height instead.

display.screen_mode.windowed.width (int)
The requested windowed width in pixels. When using windowed mode, the program will try using this width, unless display.screen.use_desktop_res is true.

display.screen_mode.windowed.pos (dir)

display.screen_mode.windowed.pos.y (int)
The last y coordinate position of the window when it was in windowed mode.

display.screen_mode.windowed.pos.x (int)
The last x coordinate position of the window when it was in windowed mode.

display.screen_mode.fullscreen (dir)

display.screen_mode.fullscreen.height (int)
This is like display.screen_mode.fullscreen.width, but for the height instead.

display.screen_mode.fullscreen.use_desktop_res (bool)
If true (and display.fullscreen is true), then the desktop resolution will be used for setting the vars display.screen.width and display.screen.height. If false, the vars display.screen_mode.fullscreen.width and display.screen_mode.fullscreen.height will be used instead.

display.screen_mode.fullscreen.width (int)
The requested fullscreen width in pixels. When using fullscreen mode, the program will try using this width, unless display.screen_mode.fullscreen.use_desktop_res is true.

display.camera_params (dir)

display.camera_params.zoom (float)
How much the camera is zoomed in. 1.0 is the normal amount.

display.camera_params.vfov (float)
This is the "vertical field of view" of the game's camera.

display.camera_params.a_ratio (dir)

display.camera_params.a_ratio.use_screen_resolution (bool)
If this is set to true, then the variable display.camera_params.a_ratio.value will be set to the screen width divided by the screen height.

display.camera_params.a_ratio.value (float)
Let the aratio be the value of this var. Let vfov be the value of display.camera_params.vfov. The hfov (horizontal field of view) is set to vfov * aratio. The world is rendered using the vfov and the hfov.

display.screenshot (dir)

display.screenshot.display_msg (bool)

display.screenshot.last_ss_used_steam (bool)

display.screenshot.fn_ext (string)
This should be either "jpg" or "png". This specifies the filetype of screenshots that are generated.

display.screenshot.use_steam (bool)
If true, then the Steam API will be used to take screenshots when Steam is running. Otherwise, the game will use its own function to take screenshots.

sound (dir)

sound.cur_song (string)

sound.rep_required_delta (float)
When two identical sounds are played very close to each other in time, the second one will not be played. This var specifies how long we have to wait after the first sound before the second can be played.

sound.cur_playlist (string)

sound.engine (dir)

sound.engine.err_could_not_init_sound_lib (bool)
This is set to true if the program is unable to initialize the sound library. When this happens, the program will continue without any sound. Failure to initialize the sound library might be caused by the inability to find an audio device.

sound.music (dir)

sound.music.fade_in_ms (int)
The fade in time, in milliseconds, of music.

sound.music.paused (bool)
Whether or not the music is paused. You cannot modify this variable: it is set every frame by the engine.

sound.music.fade_out_ms (int)
The fade out time, in milliseconds, of music.

sound.music.pause_when_window_no_focus (bool)
When this is true, the music is paused when the window does not have the focus.

sound.music.volume (float)
The music volume. This should be between 0.0 and 1.0.

sound.sound (dir)

sound.sound.volume (float)
The sound volume. This should be between 0.0 and 1.0.

game (dir)
When a game is loaded, variables will be added here. When a game is closed, these variables will be removed. There are a few exceptions: a few variables need to exist here even if there is no game loaded. One such var is "game.state.world_loaded". Another is game.version.error.1.forced_preferred_engine_ver.

game.automatic_saving (bool)

game.globals (dir)
These are vars created by the package, as opposed to "system" game vars.

game.globals.temp (dir)

game.globals.temp.hurt_sound_cooldown_6_2 (float)

game.globals.temp.hurt_sound_cooldown_7_1 (float)

game.globals.temp.hurt_sound_cooldown_2_2 (float)

game.globals.temp.hurt_sound_cooldown_2_1 (float)

game.globals.temp.hurt_sound_cooldown_1_2 (float)

game.globals.temp.hurt_sound_cooldown_1_1 (float)

game.globals.temp.hurt_sound_cooldown_3_1 (float)

game.globals.temp.hurt_sound_cooldown_7_2 (float)

game.globals.temp.hurt_sound_cooldown_5_1 (float)

game.globals.temp.hurt_sound_cooldown_3_2 (float)

game.globals.temp.hurt_sound_cooldown_4_2 (float)

game.globals.temp.hurt_sound_cooldown_4_1 (float)

game.globals.temp.hurt_sound_cooldown_5_2 (float)

game.globals.temp.hurt_sound_cooldown_6_1 (float)

game.globals.game (dir)

game.globals.game.globals (dir)

game.globals.game.globals.xar (dir)

game.globals.game.globals.xar.player (dir)

game.globals.game.globals.xar.player.telekinesis (dir)

game.globals.game.globals.xar.player.telekinesis.beta_sponge (bool)

game.globals.game.globals.xar.player.telekinesis.secret_farmhouse (bool)

game.globals.game.globals.xar.player.telekinesis.mylantis_great_cavern (bool)

game.globals.game.globals.xar.player.telekinesis.main_branch_lib (bool)

game.globals.game.globals.xar.player.telekinesis.super_massive_black_hole (bool)

game.globals.game.globals.xar.player.telekinesis.stone_corral (bool)

game.globals.game.globals.xar.player.telekinesis.starksboro (bool)

game.globals.game.globals.xar.player.telekinesis.top_of_world (bool)

game.globals.game.globals.xar.player.telekinesis.huntington (bool)

game.globals.game.globals.xar.player.telekinesis.desert_flower_cloud (bool)

game.globals.game.globals.xar.player.telekinesis.tangerine (bool)

game.globals.xar (dir)

game.globals.xar.normal_bent_touch_dist (float)

game.globals.xar.emp_end_time (float)

game.globals.xar.damage_5x_stacking_time (float)

game.globals.xar.xp_5x_stacking_time (float)

game.globals.xar.first_life (bool)

game.globals.xar.invun_stacking_time (float)

game.globals.xar.movement (dir)

game.globals.xar.movement.move_on_z_axis (bool)

game.globals.xar.movement.extra_impulse (vector)

game.globals.xar.movement.forward (bool)

game.globals.xar.movement.up (bool)

game.globals.xar.movement.back (bool)

game.globals.xar.movement.spin_cw (bool)

game.globals.xar.movement.left (bool)

game.globals.xar.movement.rocket (bool)

game.globals.xar.movement.spin_ccw (bool)

game.globals.xar.movement.right (bool)

game.globals.xar.movement.down (bool)

game.globals.xar.movement.brake (bool)

game.globals.xar.movement.roll_value (float)

game.globals.xar.movement.alt_level_radius (dir)

game.globals.xar.movement.alt_level_radius.old_radius (int)

game.globals.xar.movement.alt_level_radius.is_using (bool)

game.globals.xar.door_unlocked (dir)

game.globals.xar.door_unlocked.hell (bool)

game.globals.xar.door_unlocked.i3 (bool)

game.globals.xar.door_unlocked.i1 (bool)

game.globals.xar.door_unlocked.burlington (bool)

game.globals.xar.door_unlocked.i2 (bool)

game.globals.xar.world_pos (dir)

game.globals.xar.world_pos.bookmark (dir)

game.globals.xar.world_pos.bookmark.has (bool)

game.globals.xar.world_pos.bookmark.path (string)

game.globals.xar.world_pos.bookmark.lbp (dir)

game.globals.xar.world_pos.bookmark.lbp.x (int)

game.globals.xar.world_pos.bookmark.lbp.z (int)

game.globals.xar.world_pos.bookmark.lbp.y (int)

game.globals.xar.key_time (dir)

game.globals.xar.key_time.dans_house (float)

game.globals.xar.key_time.blue (float)

game.globals.xar.key_time.yellow (float)

game.globals.xar.key_time.green_combo (string)

game.globals.xar.key_time.green (float)

game.globals.xar.key_time.laser_genesis (float)

game.globals.xar.key_time.universe (float)

game.globals.xar.inv_exec (dir)

game.globals.xar.inv_exec.wep_script_last_wep (int)

game.globals.xar.inv_exec.primary (bool)

game.globals.xar.inv_exec.cur_wep (int)

game.globals.xar.inv_exec.starting_shoot (bool)

game.globals.xar.inv_exec.last_fire_time (float)

game.globals.xar.inv_exec.wep_script_in (bool)

game.globals.xar.player (dir)

game.globals.xar.player.tracking_marker_dist (float)

game.globals.xar.player.tracking_marker_dir (vector)

game.globals.xar.player.cheat_comon_markers (bool)

game.globals.xar.player.tracking_marker (int)

game.globals.xar.player.tracking_marker_hide (bool)

game.globals.xar.player.tracking_marker_last_id (int)

game.globals.xar.player.tracking_marker_path (string)

game.globals.xar.player.cur_wep (int)

game.globals.xar.player.tracking_marker_last_time (float)

game.globals.xar.player.gun8 (dir)

game.globals.xar.player.gun8.last_last_mode (int)

game.globals.xar.player.gun8.ammo_level (int)

game.globals.xar.player.gun8.ammo (int)

game.globals.xar.player.gun8.last_mode (int)

game.globals.xar.player.gun8.freeze_time_level (int)

game.globals.xar.player.gun8.last_sound_time (float)

game.globals.xar.player.gun8.damage_level (int)

game.globals.xar.player.gun8.radius_level (int)

game.globals.xar.player.gun8.mode2 (dir)

game.globals.xar.player.gun8.mode2.equipped (bool)

game.globals.xar.player.gun8.mode2.has (bool)

game.globals.xar.player.gun8.mode1 (dir)

game.globals.xar.player.gun8.mode1.equipped (bool)

game.globals.xar.player.gun8.mode1.has (bool)

game.globals.xar.player.gun7 (dir)

game.globals.xar.player.gun7.last_last_mode (int)

game.globals.xar.player.gun7.ammo_level (int)

game.globals.xar.player.gun7.ammo (int)

game.globals.xar.player.gun7.fire_period_level (int)

game.globals.xar.player.gun7.last_mode (int)

game.globals.xar.player.gun7.damage_level (int)

game.globals.xar.player.gun7.mode4 (dir)

game.globals.xar.player.gun7.mode4.equipped (bool)

game.globals.xar.player.gun7.mode4.has (bool)

game.globals.xar.player.gun7.mode3 (dir)

game.globals.xar.player.gun7.mode3.equipped (bool)

game.globals.xar.player.gun7.mode3.has (bool)

game.globals.xar.player.gun7.mode1 (dir)

game.globals.xar.player.gun7.mode1.equipped (bool)

game.globals.xar.player.gun7.mode1.has (bool)

game.globals.xar.player.gun7.mode2 (dir)

game.globals.xar.player.gun7.mode2.equipped (bool)

game.globals.xar.player.gun7.mode2.has (bool)

game.globals.xar.player.gun0 (dir)

game.globals.xar.player.gun0.quasar_drive_end (float)

game.globals.xar.player.gun0.last_last_mode (int)

game.globals.xar.player.gun0.charge (int)

game.globals.xar.player.gun0.start_shoot_time (float)

game.globals.xar.player.gun0.ammo_level (int)

game.globals.xar.player.gun0.ammo (int)

game.globals.xar.player.gun0.black_hole_drive_end (float)

game.globals.xar.player.gun0.speed_level (int)

game.globals.xar.player.gun0.damage_level (int)

game.globals.xar.player.gun0.last_mode (int)

game.globals.xar.player.gun0.mode4 (dir)

game.globals.xar.player.gun0.mode4.equipped (bool)

game.globals.xar.player.gun0.mode4.has (bool)

game.globals.xar.player.gun0.mode3 (dir)

game.globals.xar.player.gun0.mode3.equipped (bool)

game.globals.xar.player.gun0.mode3.has (bool)

game.globals.xar.player.gun0.mode1 (dir)

game.globals.xar.player.gun0.mode1.equipped (bool)

game.globals.xar.player.gun0.mode1.has (bool)

game.globals.xar.player.gun0.mode2 (dir)

game.globals.xar.player.gun0.mode2.equipped (bool)

game.globals.xar.player.gun0.mode2.has (bool)

game.globals.xar.player.gun6 (dir)

game.globals.xar.player.gun6.last_last_mode (int)

game.globals.xar.player.gun6.last_mode (int)

game.globals.xar.player.gun6.num_level (int)

game.globals.xar.player.gun6.speed_level (int)

game.globals.xar.player.gun6.damage_level (int)

game.globals.xar.player.gun6.ammo_level (int)

game.globals.xar.player.gun6.ammo (int)

game.globals.xar.player.gun6.fire_period_level (int)

game.globals.xar.player.gun6.mode2 (dir)

game.globals.xar.player.gun6.mode2.equipped (bool)

game.globals.xar.player.gun6.mode2.has (bool)

game.globals.xar.player.gun6.mode1 (dir)

game.globals.xar.player.gun6.mode1.equipped (bool)

game.globals.xar.player.gun6.mode1.has (bool)

game.globals.xar.player.trophy (dir)

game.globals.xar.player.trophy.alpha_cube (bool)

game.globals.xar.player.trophy.apple_tree (bool)

game.globals.xar.player.trophy.credits (bool)

game.globals.xar.player.trophy.amethyst_maze (bool)

game.globals.xar.player.trophy.emerald (bool)

game.globals.xar.player.trophy.topaz (bool)

game.globals.xar.player.trophy.edge_of_world (bool)

game.globals.xar.player.trophy.sponge_beta (bool)

game.globals.xar.player.trophy.sapphire_maze (bool)

game.globals.xar.player.trophy.small_white_flower (bool)

game.globals.xar.player.trophy.laser_genesis (bool)

game.globals.xar.player.trophy.sponge_alpha (bool)

game.globals.xar.player.trophy.black_cube (bool)

game.globals.xar.player.trophy.small_black_flower (bool)

game.globals.xar.player.trophy.moon_ice (bool)

game.globals.xar.player.trophy.williston_caves (bool)

game.globals.xar.player.trophy.williston (bool)

game.globals.xar.player.trophy.bristol (bool)

game.globals.xar.player.trophy.raspberry (bool)

game.globals.xar.player.trophy.mylantis (bool)

game.globals.xar.player.trophy.lighthouse (bool)

game.globals.xar.player.trophy.green_apple_club (bool)

game.globals.xar.player.trophy.river (bool)

game.globals.xar.player.trophy.denver (bool)

game.globals.xar.player.trophy.botany_lab_6 (bool)

game.globals.xar.player.trophy.botany_lab_5 (bool)

game.globals.xar.player.trophy.red_maze_flower (bool)

game.globals.xar.player.trophy.willow_tree (bool)

game.globals.xar.player.trophy.inner_core (bool)

game.globals.xar.player.trophy.zube_castle (bool)

game.globals.xar.player.trophy.botany_lab_3 (bool)

game.globals.xar.player.trophy.botany_lab_2 (bool)

game.globals.xar.player.trophy.ying_tower (bool)

game.globals.xar.player.trophy.blue_bubble (bool)

game.globals.xar.player.trophy.health_tower (bool)

game.globals.xar.player.trophy.willow_tree_dark (bool)

game.globals.xar.player.trophy.infinity_flower (bool)

game.globals.xar.player.trophy.blue_bubble_breach (bool)

game.globals.xar.player.trophy.burlington_cols (bool)

game.globals.xar.player.trophy.tweed_cave (bool)

game.globals.xar.player.trophy.catacombs (bool)

game.globals.xar.player.trophy.ying_island_3 (bool)

game.globals.xar.player.trophy.blue_mushroom (bool)

game.globals.xar.player.trophy.ying_flower (bool)

game.globals.xar.player.trophy.ying_island_2 (bool)

game.globals.xar.player.trophy.library_ying (bool)

game.globals.xar.player.trophy.wig_prison (bool)

game.globals.xar.player.trophy.moon_beta (bool)

game.globals.xar.player.trophy.tau_caves_map (bool)

game.globals.xar.player.trophy.salmon_mushroom (bool)

game.globals.xar.player.trophy.jericho (bool)

game.globals.xar.player.trophy.small_cannon_pyramid (bool)

game.globals.xar.player.trophy.blackberry (bool)

game.globals.xar.player.trophy.ice_cube (bool)

game.globals.xar.player.trophy.botany_lab_4 (bool)

game.globals.xar.player.trophy.noob_flower (bool)

game.globals.xar.player.trophy.cactus (bool)

game.globals.xar.player.trophy.orange (bool)

game.globals.xar.player.trophy.richmond (bool)

game.globals.xar.player.trophy.stoney_cave_3 (bool)

game.globals.xar.player.trophy.ying_island_1 (bool)

game.globals.xar.player.trophy.large_cannon_pyramid (bool)

game.globals.xar.player.trophy.moon_alpha (bool)

game.globals.xar.player.trophy.desert_cave (bool)

game.globals.xar.player.trophy.emp_castle (bool)

game.globals.xar.player.trophy.ying_exit_maze (bool)

game.globals.xar.player.trophy.botany_lab_1 (bool)

game.globals.xar.player.trophy.richmond_sewers (bool)

game.globals.xar.player.trophy.small_yellow_flower (bool)

game.globals.xar.player.trophy.stoney_cave_2 (bool)

game.globals.xar.player.trophy.ying_island_4 (bool)

game.globals.xar.player.trophy.deep_sliver_maze (bool)

game.globals.xar.player.trophy.richmond_caves (bool)

game.globals.xar.player.trophy.stoney_cave_1 (bool)

game.globals.xar.player.trophy.toronto (bool)

game.globals.xar.player.trophy.toronto_underground (bool)

game.globals.xar.player.trophy.stoney_church (bool)

game.globals.xar.player.trophy.montreal (bool)

game.globals.xar.player.trophy.danville (bool)

game.globals.xar.player.trophy.aladdin_cave (bool)

game.globals.xar.player.trophy.small_blue_flower_1 (bool)

game.globals.xar.player.trophy.small_blue_flower_2 (bool)

game.globals.xar.player.trophy.mystic_vine (bool)

game.globals.xar.player.trophy.weed_rings (bool)

game.globals.xar.player.trophy.fanatic_spire (bool)

game.globals.xar.player.trophy.farmhouse (bool)

game.globals.xar.player.trophy.creeping_jeni (bool)

game.globals.xar.player.trophy.violets (bool)

game.globals.xar.player.trophy.inner_tree (bool)

game.globals.xar.player.trophy.planet_clay (bool)

game.globals.xar.player.trophy.library_i3 (bool)

game.globals.xar.player.trophy.moon_fire_rate (bool)

game.globals.xar.player.trophy.iolite (bool)

game.globals.xar.player.trophy.colchester (bool)

game.globals.xar.player.trophy.yellow_mushroom (bool)

game.globals.xar.player.trophy.jackfruit (bool)

game.globals.xar.player.trophy.large_white_flower (bool)

game.globals.xar.player.trophy.sun (bool)

game.globals.xar.player.trophy.desert_flower (bool)

game.globals.xar.player.trophy.jumbo_yellow_flower (bool)

game.globals.xar.player.trophy.black_mushroom (bool)

game.globals.xar.player.trophy.red_mushroom (bool)

game.globals.xar.player.trophy.tangerine (bool)

game.globals.xar.player.trophy.hell_flower (bool)

game.globals.xar.player.trophy.library_i1 (bool)

game.globals.xar.player.trophy.st_i3_treetop (bool)

game.globals.xar.player.trophy.burlington (bool)

game.globals.xar.player.trophy.tegan_garden (bool)

game.globals.xar.player.trophy.library_space (bool)

game.globals.xar.player.trophy.library_i2 (bool)

game.globals.xar.player.trophy.moon_gamma (bool)

game.globals.xar.player.trophy.sponge_pure (bool)

game.globals.xar.player.trophy.ice_castle (bool)

game.globals.xar.player.trophy.moon_tau (bool)

game.globals.xar.player.trophy.planet_small_minigun (bool)

game.globals.xar.player.gold (dir)

game.globals.xar.player.gold.max (int)

game.globals.xar.player.gold.amount (int)

game.globals.xar.player.shield (dir)

game.globals.xar.player.shield.counter (float)

game.globals.xar.player.shield.amount (int)

game.globals.xar.player.shield.max (int)

game.globals.xar.player.health (dir)

game.globals.xar.player.health.regen_level (int)

game.globals.xar.player.health.extra_regen (float)

game.globals.xar.player.health.extra_regen_level (int)

game.globals.xar.player.health.amount (int)

game.globals.xar.player.health.regen (float)

game.globals.xar.player.health.level (int)

game.globals.xar.player.health.counter (float)

game.globals.xar.player.health.max (int)

game.globals.xar.player.health.too_much_counter (float)

game.globals.xar.player.gun9 (dir)

game.globals.xar.player.gun9.last_last_mode (int)

game.globals.xar.player.gun9.last_mode (int)

game.globals.xar.player.gun9.ammo_level (int)

game.globals.xar.player.gun9.ammo (int)

game.globals.xar.player.gun9.speed_level (int)

game.globals.xar.player.gun9.damage_level (int)

game.globals.xar.player.gun9.radius_level (int)

game.globals.xar.player.gun9.mode3 (dir)

game.globals.xar.player.gun9.mode3.equipped (bool)

game.globals.xar.player.gun9.mode3.has (bool)

game.globals.xar.player.gun9.mode1 (dir)

game.globals.xar.player.gun9.mode1.equipped (bool)

game.globals.xar.player.gun9.mode1.has (bool)

game.globals.xar.player.gun9.mode2 (dir)

game.globals.xar.player.gun9.mode2.equipped (bool)

game.globals.xar.player.gun9.mode2.has (bool)

game.globals.xar.player.armor (dir)

game.globals.xar.player.armor.regen (float)

game.globals.xar.player.armor.regen_level (int)

game.globals.xar.player.armor.counter (float)

game.globals.xar.player.armor.amount (int)

game.globals.xar.player.armor.max (int)

game.globals.xar.player.arcade (dir)

game.globals.xar.player.arcade.armor (int)

game.globals.xar.player.arcade.inside (bool)

game.globals.xar.player.arcade.health (int)

game.globals.xar.player.arcade.ammo (dir)

game.globals.xar.player.arcade.ammo.0 (int)

game.globals.xar.player.arcade.ammo.9 (int)

game.globals.xar.player.arcade.ammo.8 (int)

game.globals.xar.player.arcade.ammo.7 (int)

game.globals.xar.player.arcade.ammo.2 (int)

game.globals.xar.player.arcade.ammo.4 (int)

game.globals.xar.player.arcade.ammo.1 (int)

game.globals.xar.player.arcade.ammo.3 (int)

game.globals.xar.player.arcade.ammo.6 (int)

game.globals.xar.player.arcade.ammo.5 (int)

game.globals.xar.player.hive_attack (dir)

game.globals.xar.player.hive_attack.last_time (float)

game.globals.xar.player.hive_attack.meter (float)

game.globals.xar.player.equipped (dir)

game.globals.xar.player.equipped.0 (dir)

game.globals.xar.player.equipped.0.secondary (string)

game.globals.xar.player.equipped.0.primary (string)

game.globals.xar.player.equipped.9 (dir)

game.globals.xar.player.equipped.9.secondary (string)

game.globals.xar.player.equipped.9.primary (string)

game.globals.xar.player.equipped.8 (dir)

game.globals.xar.player.equipped.8.secondary (string)

game.globals.xar.player.equipped.8.primary (string)

game.globals.xar.player.equipped.7 (dir)

game.globals.xar.player.equipped.7.secondary (string)

game.globals.xar.player.equipped.7.primary (string)

game.globals.xar.player.equipped.2 (dir)

game.globals.xar.player.equipped.2.secondary (string)

game.globals.xar.player.equipped.2.primary (string)

game.globals.xar.player.equipped.4 (dir)

game.globals.xar.player.equipped.4.secondary (string)

game.globals.xar.player.equipped.4.primary (string)

game.globals.xar.player.equipped.1 (dir)

game.globals.xar.player.equipped.1.secondary (string)

game.globals.xar.player.equipped.1.primary (string)

game.globals.xar.player.equipped.3 (dir)

game.globals.xar.player.equipped.3.secondary (string)

game.globals.xar.player.equipped.3.primary (string)

game.globals.xar.player.equipped.6 (dir)

game.globals.xar.player.equipped.6.secondary (string)

game.globals.xar.player.equipped.6.primary (string)

game.globals.xar.player.equipped.5 (dir)

game.globals.xar.player.equipped.5.secondary (string)

game.globals.xar.player.equipped.5.primary (string)

game.globals.xar.player.markers (dir)

game.globals.xar.player.markers.num_short (int)

game.globals.xar.player.gun1 (dir)

game.globals.xar.player.gun1.last_last_mode (int)

game.globals.xar.player.gun1.last_mode (int)

game.globals.xar.player.gun1.damage_level (int)

game.globals.xar.player.gun1.fire_period_level (int)

game.globals.xar.player.gun1.ammo_level (int)

game.globals.xar.player.gun1.ammo (int)

game.globals.xar.player.gun1.ammo_regen_level (int)

game.globals.xar.player.gun1.counter (float)

game.globals.xar.player.gun1.speed_level (int)

game.globals.xar.player.gun1.mode2 (dir)

game.globals.xar.player.gun1.mode2.equipped (bool)

game.globals.xar.player.gun1.mode2.has (bool)

game.globals.xar.player.gun1.mode1 (dir)

game.globals.xar.player.gun1.mode1.equipped (bool)

game.globals.xar.player.gun1.mode1.has (bool)

game.globals.xar.player.gun1.mode6 (dir)

game.globals.xar.player.gun1.mode6.equipped (bool)

game.globals.xar.player.gun1.mode6.has (bool)

game.globals.xar.player.gun1.mode3 (dir)

game.globals.xar.player.gun1.mode3.equipped (bool)

game.globals.xar.player.gun1.mode3.has (bool)

game.globals.xar.player.gun1.mode5 (dir)

game.globals.xar.player.gun1.mode5.equipped (bool)

game.globals.xar.player.gun1.mode5.has (bool)

game.globals.xar.player.gun1.mode4 (dir)

game.globals.xar.player.gun1.mode4.equipped (bool)

game.globals.xar.player.gun1.mode4.has (bool)

game.globals.xar.player.gun5 (dir)

game.globals.xar.player.gun5.last_last_mode (int)

game.globals.xar.player.gun5.last_mode (int)

game.globals.xar.player.gun5.speed_level (int)

game.globals.xar.player.gun5.damage_level (int)

game.globals.xar.player.gun5.ammo_level (int)

game.globals.xar.player.gun5.ammo (int)

game.globals.xar.player.gun5.fire_period_level (int)

game.globals.xar.player.gun5.bucket (dir)

game.globals.xar.player.gun5.bucket.19 (int)

game.globals.xar.player.gun5.bucket.17 (int)

game.globals.xar.player.gun5.bucket.16 (int)

game.globals.xar.player.gun5.bucket.14 (int)

game.globals.xar.player.gun5.bucket.12 (int)

game.globals.xar.player.gun5.bucket.11 (int)

game.globals.xar.player.gun5.bucket.1 (int)

game.globals.xar.player.gun5.bucket.4 (int)

game.globals.xar.player.gun5.bucket.next_release_time (float)

game.globals.xar.player.gun5.bucket.18 (int)

game.globals.xar.player.gun5.bucket.15 (int)

game.globals.xar.player.gun5.bucket.2 (int)

game.globals.xar.player.gun5.bucket.20 (int)

game.globals.xar.player.gun5.bucket.5 (int)

game.globals.xar.player.gun5.bucket.3 (int)

game.globals.xar.player.gun5.bucket.8 (int)

game.globals.xar.player.gun5.bucket.6 (int)

game.globals.xar.player.gun5.bucket.9 (int)

game.globals.xar.player.gun5.bucket.13 (int)

game.globals.xar.player.gun5.bucket.7 (int)

game.globals.xar.player.gun5.bucket.10 (int)

game.globals.xar.player.gun5.mode1 (dir)

game.globals.xar.player.gun5.mode1.equipped (bool)

game.globals.xar.player.gun5.mode1.has (bool)

game.globals.xar.player.gun5.mode2 (dir)

game.globals.xar.player.gun5.mode2.equipped (bool)

game.globals.xar.player.gun5.mode2.has (bool)

game.globals.xar.player.gun4 (dir)

game.globals.xar.player.gun4.last_last_mode (int)

game.globals.xar.player.gun4.last_mode (int)

game.globals.xar.player.gun4.radius_level (int)

game.globals.xar.player.gun4.speed_level (int)

game.globals.xar.player.gun4.damage_level (int)

game.globals.xar.player.gun4.ammo_level (int)

game.globals.xar.player.gun4.ammo (int)

game.globals.xar.player.gun4.fire_period_level (int)

game.globals.xar.player.gun4.mode4 (dir)

game.globals.xar.player.gun4.mode4.equipped (bool)

game.globals.xar.player.gun4.mode4.has (bool)

game.globals.xar.player.gun4.mode3 (dir)

game.globals.xar.player.gun4.mode3.equipped (bool)

game.globals.xar.player.gun4.mode3.has (bool)

game.globals.xar.player.gun4.mode5 (dir)

game.globals.xar.player.gun4.mode5.equipped (bool)

game.globals.xar.player.gun4.mode5.has (bool)

game.globals.xar.player.gun4.mode1 (dir)

game.globals.xar.player.gun4.mode1.equipped (bool)

game.globals.xar.player.gun4.mode1.has (bool)

game.globals.xar.player.gun4.mode2 (dir)

game.globals.xar.player.gun4.mode2.equipped (bool)

game.globals.xar.player.gun4.mode2.has (bool)

game.globals.xar.player.gun2 (dir)

game.globals.xar.player.gun2.last_last_mode (int)

game.globals.xar.player.gun2.last_mode (int)

game.globals.xar.player.gun2.num_level (int)

game.globals.xar.player.gun2.speed_level (int)

game.globals.xar.player.gun2.damage_level (int)

game.globals.xar.player.gun2.ammo_level (int)

game.globals.xar.player.gun2.ammo (int)

game.globals.xar.player.gun2.fire_period_level (int)

game.globals.xar.player.gun2.mode3 (dir)

game.globals.xar.player.gun2.mode3.equipped (bool)

game.globals.xar.player.gun2.mode3.has (bool)

game.globals.xar.player.gun2.mode1 (dir)

game.globals.xar.player.gun2.mode1.equipped (bool)

game.globals.xar.player.gun2.mode1.has (bool)

game.globals.xar.player.gun2.mode2 (dir)

game.globals.xar.player.gun2.mode2.equipped (bool)

game.globals.xar.player.gun2.mode2.has (bool)

game.globals.xar.player.gun3 (dir)

game.globals.xar.player.gun3.last_last_mode (int)

game.globals.xar.player.gun3.ammo_level (int)

game.globals.xar.player.gun3.ammo (int)

game.globals.xar.player.gun3.damage_level (int)

game.globals.xar.player.gun3.last_mode (int)

game.globals.xar.player.gun3.freeze_time_level (int)

game.globals.xar.player.gun3.num_level (int)

game.globals.xar.player.gun3.mode4 (dir)

game.globals.xar.player.gun3.mode4.equipped (bool)

game.globals.xar.player.gun3.mode4.has (bool)

game.globals.xar.player.gun3.mode3 (dir)

game.globals.xar.player.gun3.mode3.equipped (bool)

game.globals.xar.player.gun3.mode3.has (bool)

game.globals.xar.player.gun3.mode1 (dir)

game.globals.xar.player.gun3.mode1.equipped (bool)

game.globals.xar.player.gun3.mode1.has (bool)

game.globals.xar.player.gun3.mode2 (dir)

game.globals.xar.player.gun3.mode2.equipped (bool)

game.globals.xar.player.gun3.mode2.has (bool)

game.globals.xar.hurt_sound (dir)

game.globals.xar.hurt_sound.damage (int)

game.globals.xar.hurt_sound.last_time (float)

game.globals.xar.sound (dir)

game.globals.xar.sound.print_broken_playlist_errs_to_stdout (bool)

game.globals.xar.sound.print_broken_playlist_errs_to_console (bool)

game.globals.xar.hud (dir)

game.globals.xar.hud.armor_danger_cutoff (float)

game.globals.xar.hud.health_danger_cutoff (float)

game.globals.xar.hud.show_ammo (bool)

game.globals.xar.hud.disable_hud (bool)

game.globals.xar.hud.show_health (bool)

game.globals.xar.hud.show_game_time (bool)

game.globals.xar.hud.show_markers (bool)

game.globals.xar.hud.show_gold (bool)

game.globals.xar.hud.showing_border (bool)

game.globals.xar.hud.show_experience (bool)

game.globals.xar.hud.show_icons (bool)

game.globals.xar.hud.show_play_time (bool)

game.globals.xar.hud.shield_danger_cutoff (float)

game.globals.xar.hud.flash (dir)

game.globals.xar.hud.flash.color (vector)

game.globals.xar.hud.flash.alpha (float)

game.globals.xar.hud.flash.last_time (float)

game.globals.xar.hud.flash.duration (float)

game.globals.xar.hud.msg (dir)

game.globals.xar.hud.msg.show_spiral_of_death_msg (bool)

game.globals.xar.hud.msg.disable_msgs (bool)

game.globals.xar.hud.msg.show_saved_game_msg (bool)

game.globals.xar.create_start_pos (dir)

game.globals.xar.create_start_pos.fast_track (bool)

game.globals.xar.create_start_pos.cur_level (int)

game.globals.xar.create_start_pos.which_try (int)

game.globals.xar.create_start_pos.next_seed (int)

game.globals.xar.create_start_pos.splash (string)

game.globals.xar.create_start_pos.global_tries_max (int)

game.globals.xar.create_start_pos.state (string)

game.globals.xar.create_start_pos.global_tries (int)

game.globals.xar.create_start_pos.frac (float)

game.globals.xar.messages (dir)

game.globals.xar.messages.slot5 (dir)

game.globals.xar.messages.slot5.ttl (float)

game.globals.xar.messages.slot5.msg (string)

game.globals.xar.messages.slot4 (dir)

game.globals.xar.messages.slot4.ttl (float)

game.globals.xar.messages.slot4.msg (string)

game.globals.xar.messages.slot3 (dir)

game.globals.xar.messages.slot3.ttl (float)

game.globals.xar.messages.slot3.msg (string)

game.globals.xar.messages.slot1 (dir)

game.globals.xar.messages.slot1.ttl (float)

game.globals.xar.messages.slot1.msg (string)

game.globals.xar.messages.slot2 (dir)

game.globals.xar.messages.slot2.ttl (float)

game.globals.xar.messages.slot2.msg (string)

game.globals.xar.stats (dir)

game.globals.xar.stats.kill_count (int)

game.globals.xar.difficulty (dir)

game.globals.xar.difficulty.speedrun_start (float)

game.globals.xar.difficulty.trying_to_be_pacifist (bool)

game.globals.xar.difficulty.custom (bool)

game.globals.xar.difficulty.hard_4_once (bool)

game.globals.xar.difficulty.hard_4 (bool)

game.globals.xar.difficulty.hard_3_once (bool)

game.globals.xar.difficulty.hard_3 (bool)

game.globals.xar.difficulty.easy_1 (bool)

game.globals.xar.difficulty.hard_2_once (bool)

game.globals.xar.difficulty.locked_in (bool)

game.globals.xar.difficulty.easy_2_once (bool)

game.globals.xar.difficulty.easy_1_once (bool)

game.globals.xar.difficulty.hard_1_once (bool)

game.globals.xar.difficulty.hard_1 (bool)

game.globals.xar.difficulty.easy_2 (bool)

game.globals.xar.difficulty.normal (bool)

game.globals.xar.difficulty.normal_once (bool)

game.globals.xar.difficulty.hard_2 (bool)

game.globals.xar.difficulty.curve (dir)

game.globals.xar.difficulty.curve.enabled (bool)

game.globals.xar.difficulty.curve.player_in_damage (dir)

game.globals.xar.difficulty.curve.player_in_damage.last_time (float)

game.globals.xar.difficulty.curve.player_in_damage.total (int)

game.globals.xar.difficulty.custom (bool)

game.globals.xar.difficulty.custom.dmg_to_player (float)

game.globals.xar.difficulty.custom.dmg_from_player (float)

game.globals.xar.visual_effect (dir)

game.globals.xar.visual_effect.block_blind (dir)

game.globals.xar.visual_effect.block_blind.got_a_hit_old (bool)

game.globals.xar.visual_effect.block_blind.got_a_hit (bool)

game.globals.xar.visual_effect.block_blind.cur_shade (float)

game.globals.xar.visual_effect.block_blind.last_time (float)

game.globals.xar.cheat (dir)

game.globals.xar.cheat.free_markers (bool)

game.globals.xar.cheat.inf2 (dir)

game.globals.xar.cheat.inf2.secondary_bt (string)

game.globals.xar.cheat.inf2.enabled (bool)

game.globals.xar.cheat.inf2.primary_bt (string)

game.globals.xar.inf2 (dir)

game.globals.xar.inf2.movement (dir)

game.globals.xar.inf2.movement.in_air (bool)

game.globals.xar.inf2.movement.mod (string)

game.globals.xar.inf2.movement.moving_in_plane (bool)

game.globals.xar.input (dir)

game.globals.xar.input.holding_drop_marker_start (float)

game.globals.xar.input.holding_telekinesis_start (float)

game.globals.xar.input.holding_drop_marker (bool)

game.globals.xar.input.use_primary_uses_object (bool)

game.globals.xar.input.last_free_telekinesis_time (float)

game.globals.xar.input.use_secondary_uses_object (bool)

game.globals.xar.credits (dir)

game.globals.xar.credits.in (bool)

game.globals.xar.credits.won_game_play_time (float)

game.globals.xar.credits.won_game (bool)

game.globals.xar.credits.won_game_game_time (float)

game.globals.xar.experience (dir)

game.globals.xar.experience.this_second (int)

game.globals.xar.experience.last_time (float)

game.globals.xar.experience.to_next_level (int)

game.globals.xar.experience.level_step (int)

game.globals.xar.experience.last_claimed_milestone_level (int)

game.globals.xar.experience.last_second (int)

game.globals.xar.experience.level (int)

game.globals.xar.experience.total (int)

game.globals.xar.experience.to_next_level_max (int)

game.globals.worldgen (dir)

game.globals.worldgen.state (dir)

game.globals.worldgen.state.no_stable_sing (bool)

game.globals.worldgen.state.one_way (bool)

game.globals.worldgen.state.genesis (bool)

game.globals.worldgen.state.low_ammo (bool)

game.globals.worldgen.state.low_max_ammo (bool)

game.globals.worldgen.state.low_buy_upgrades (bool)

game.input (dir)
These vars may eventually be moved to metagame.input.

game.input.last_input_time (float)
The last time there was any keyboard or mouse button input.

game.input.disable_non_escape_binds (bool)

game.input.mouse (dir)

game.input.mouse.wheel_value (int)

game.input.quick_cmd (dir)

game.input.quick_cmd.partial (string)

game.input.quick_cmd.entering (bool)

game.window (dir)

game.window.hud (dir)

game.window.hud.hide_system_hud (bool)
When true, the system hud will not be rendered. The system hud includes the crosshair, attack display, and the side displays (in the upper left and upper right).

game.version (dir)

game.version.first_engine_version (string)
The version of the engine that was used when the player was first created.

game.version.error (dir)
When we try to load a game, we may encounter an error that will terminate the loading. The errors lister here have to do with the version of the engine or the version of the package.

game.version.error.2 (dir)
Each save file stores the engine version and the package version used the last time the game was played. If when loading a game these do not match the actual engine or package version, that will terminate the loading.

game.version.error.2.expected_package_ver (string)
The package version used the last time the game was played.

game.version.error.2.expected_engine_ver (string)
The engine version used the last time the game was played.

game.version.error.1 (dir)
When loading a game, the version of the engine may not match the preferred engine version specified in the light_params.txt file of the package.

game.version.error.1.forced_preferred_engine_ver (string)
Whether to force the loading of the game, using this var to override the preferred engine version instead of the one in "light_params.txt".

game.state (dir)

game.state.saving_in_progress (bool)
When this is true, the game is in the process of being saved asynchronously.

game.state.paused (bool)
True iff the game is paused. This will happen if the user is in a menu.

game.state.close_when_done (bool)
When this is true, the program will close the game (but not exit the program) as soon as all other essential processing is done (saving locked loop, copy dir locked loop, etc).

game.state.load_when_done (bool)
When this is true, the program will reload the current game as soon as all other essential processing is done (saving locked loop, copy dir locked loop, etc).

game.state.world_loaded (bool)
This is a very important var. This says whether or not a game has been loaded. In other words, this is true iff there is a current game in play.

game.state.exit_when_done (bool)
When this is true, the program will exit as soon as all other essential processing is done (saving locked loop, copy dir locked loop, etc).

game.state.reboot_player (dir)

game.state.reboot_player.locked (bool)
When this is true, a player is being "rebooted". Rebooting consists of copying global vars, deleting the player folder, then recreating the player folder with the saved global vars.

game.state.saving (dir)

game.state.saving.saved_chunks (int)
How many modified chunks have been saved so far (since the game as been saved locked).

game.state.saving.locked (bool)
This is true iff the program is locked because a game is being saved. Saving occurs asynchronously, but it locks the program.

game.state.saving.total_chunks (int)
How many total modified chunks need to be saved (while the game is save locked).

game.state.explore_while (dir)

game.state.explore_while.window (string)
See "game.state.explore_while.func". When you call ga_explore_while, you also specify the name of a window that will be rendered each frame until the explore while callback function returns false.

game.state.explore_while.func (string)
This variable should either be the empty string or in the format "mod_name.function_name". When the game calls the function ga_explore_while, this var is set to the name of a Lua function. That function will be called over and over again, each frame, until it returns false. While that function returns true, the only game related processing the engine will do is "exploring" (creating and destroying chunks). This ga_explore_while function is intended for when the player is in spirit mode and is being transported through the chunk tree

game.state.copy_dir (dir)

game.state.copy_dir.locked (bool)
This is true iff the program is locked because a directory is being copied asynchronously.

game.player (dir)

game.player.level (int)
The level the player is on. 0 means the root of the chunk tree.

game.player.alive (bool)
This variable may eventually be removed.

game.player.name (string)
The name of the player.We must be able to create a directory of this name.

game.player.health_max (int)
Right now this is needed for the attack display, but that may eventually change.

game.player.hardcore (bool)
When this is true, whenever the player tries to exit the game (including by loading another game), the current game will be saved. Also, the package will usually enforce the rule that once you die, you cannot respawn.

game.player.path (string)
The path of the player from the root of the chunk tree. EMPTY_PATH means it is the path of length zero.Otherwise, this var should be something like 4a7_e39.

game.player.pos_valid (bool)

game.player.block_telefrag_time (float)
This is recalculated every few seconds. These returns the first time at which a block which intersects the bbox of the player will be reverted. This queries blocks on all levels.

game.player.exploration (dir)

game.player.exploration.shrink (dir)

game.player.exploration.shrink.timeout_spread (float)
See "game.player.exploration.shrink.timeout_center".

game.player.exploration.shrink.timeout_center (float)
The player is not allow to shrink again until the game time is more than game.player.exploration.shrink.timeout_spread seconds away from this timeout_center var.

game.player.camera (dir)

game.player.camera.up (vector)
The direction pointing 90 degrees from where the player is looking, towards the top of the screen.

game.player.camera.left (vector)
The direction pointing 90 degrees from where the player is looking, towards the left hand side of the screen.

game.player.camera.offset (vector)
The position of the player within the center chunk on the level of the player. The x,y,z components of this vector should always be between 0.0 and chunk_width. Because the player is in the center chunk for his level, this offset var is also the level coordinates of the player.

game.player.camera.look (vector)
Where direction where the player is looking. This vector, along with left and up, should have length one.

game.player.collision (dir)

game.player.collision.telefrag_probation_spread (float)
See "game.player.collision.telefrag_probation_center".

game.player.collision.telefrag_probation_center (float)
When the player shrinks, this variable is set to the current time. If the player telefrags an entity within game.player.telefrag_probation_spread many seconds of this probation time, then the player will be teleported back to their last "safe position".

game.player.move (dir)

game.player.move.last_pos_diff (vector)
The game is updated 25 times per second. This var represents the difference in the player's position between the last two updates. This can be used for package defined lua scripts to create momentum.

game.player.move.disable_head_turn (bool)
When set to true, moving the mouse does not cause the player's head to move.

game.player.move.mode (string)
This can be either "fly" or "ground". This determines how collision detection works with the player. In fly mode, the player is modeled using a sphere. In ground mode, the player is modeled using a cylinder.

game.player.move.ground (dir)
When the move mode is "ground", the player is modeled as a cylinder, pointed in the Z direction.

game.player.move.ground.eye_to_top (float)
This is the distance from the eyes of the player to the top of the player cylinder.

game.player.move.ground.radius (float)
This var is the radius of the player cylinder.

game.player.move.ground.bot_to_eye (float)
This is the distance from the bottom of the player cylinder to the eyes of the player. The eyes are the center of the player.

game.player.move.spirit (dir)

game.player.move.spirit.last_mode (string)
When the user sets the movement mode to "spirit", this variable is set to the current movement mode. Valid values for this variable are "fly" and "ground". When the user is in spirit mode and calls ga_move_set_body_spirit_off, their body will be restored to its previous kind (the same mode, radius, etc).

game.player.move.fly (dir)

game.player.move.fly.use_true_up (bool)
When set true, the direction from the center of the screen to the top of the screen will always point towards the positive z direction. Said another way, the "game.player.camera.left" vector will always be in the XY plane. This only has effect if the movement mode is "fly".

game.player.move.fly.radius (float)
In fly mode, the player is modeled using a sphere. This is the radius of that sphere.

game.player.respawn (dir)

game.player.respawn.path (string)
The chunk path of the chunk were the player will be respawned.

game.player.respawn.valid (bool)
This specifies whether there is a valid respawn location. If false, the player cannot be respawned.

game.player.respawn.pos (dir)
The block position, within the respawn chunk, where the player should be respawned. Note: this is be changed to a single var!

game.player.respawn.pos.x (int)

game.player.respawn.pos.z (int)

game.player.respawn.pos.y (int)

game.player.waypoint (dir)

game.player.waypoint.temp (string)
The chunk path of the temp waypoint, if a temp waypoint is being used.

game.save (dir)

game.save.chunk_db (dir)

game.save.chunk_db.dirs (string)
This is "db_1" if Chunks/ is the only database folder in the the save folder. It is "db_2" if Chunks2/ is the only database folder in the save folder. It is "db_1_and_2" if there are both folders.

game.package (dir)
When a new game is created, these vars are read in from the starting configuration file. Then, for the rest of the process of creating a new game, these vars are used.

game.package.chunk_width (int)

game.package.starting_pos_file (string)
The name of the starting configuration file used.

game.package.name (string)
The name of the package being used.

game.package.seed (int)
The seed used to generate the world. Note: the starting configuration file can specify that the user can pick their own seed when creating a new game.

game.package.config_desc (string)
A description of the initial configuration.

game.package.world_nodes (dir)

game.package.world_nodes.root_name (string)
The name of the chunk file (without the .lua at the end) to be used for the root of the chunk tree. Note: the value __FBW_DEFAULT__ can be used here, in which case the C++ hardcoded Xar world root will be used.

game.requests (dir)
Some actions do not happen immediately, but are instead requested to happen later when it is appropriate.

game.requests.type (string)
There can only be one request at a time. This var represents the current request type, such as "close" or descend.

game.requests.respawn (dir)

game.requests.respawn.str_param (string)

game.requests.tele (dir)

game.requests.tele.target_offset (vector)

game.requests.tele.path (string)

game.requests.descend (dir)

game.requests.descend.source_offset (vector)

game.requests.before_tele (dir)

game.requests.before_tele.offset (vector)

game.requests.before_tele.path (string)

game.requests.ascend (dir)

game.requests.ascend.source_offset (vector)

game.chunk_db (dir)

game.chunk_db.defrag (dir)

game.chunk_db.defrag.saves_since_last (int)
This stores how many saves have taken place since the last time the chunk database was defragged.

game.chunk_db.defrag.last_time (float)
By default, the chunk database will be defragged every hour that the user plays a saved game. This variable stores the last game time in which the chunk db was defragged.

game.time (dir)

game.time.acc (float)
The game is updated 25 times per second. Call these the major updates. However the game is rendered more often. During a rendering frame, this var represents how many seconds have passed since the last major update.

game.time.last_save (float)
The game time of when the game was last saved. This is important for the option to save the game every few seconds.

game.time.play (float)
How many seconds the player has been playing the game, since they started it as a new game. This should normally equal game.time.total, unless the player slept in the game which would advance the game.time.total time but not the game.time.play time.

game.time.date_created (int)
The time the player's folder was created. This value was returned from std::time(0).

game.time.date_last_used (int)
The time the player's folder was last used. This value was returned from std::time(0).

game.time.last_update (float)
The game time of the last major update.

game.time.rem_frac (float)
The game is updated 25 times per second. Call these the major updates. However the game is rendered more often. During a rendering frame, this var represents how far the game is from the last major update to the next major update. So 0.1 means the last major update just happened, and 0.9 means we are almost to the next major update.

game.time.total (float)
The game time. This starts at 0.0 when the player starts a new game. For every second, this advances by one. However, it can also be advanced by sleeping. So, it is not necessarily how many total seconds the player has been playing the game.

game.time.elapsed (float)
The game time that has elapsed since the last update. That is, game.time.total minus game.time.last_update should equal game.time.elapsed.

engine (dir)

engine.exit_on_error (bool)
Some program errors will not cause the program to exit. However if this var is true, then when the program encounters many of these errors it will exit explicitly.

engine.soft_loading_current (bool)
This is used by the engine.

engine.soft_loading (bool)
When this is true, when the player reloads the game, the engine will not reload certain package data (such as basic entities and moving entities). That is, the engine will retain certain package data between loads.

engine.load_stage (string)

engine.last_loaded_player (string)

engine.version (string)
The version of the program. An example would be "0.92.0".

engine.error (dir)

engine.error.out_of_memory (dir)

engine.error.out_of_memory.perform_whiskers_test (bool)
When this is true, every minute the program will allocate a 9 million byte buffer and then immediately deallocate it. This will test if the program is out of memory.

engine.error.out_of_memory.occurred (bool)
This is set to true when a memory allocation fails.

engine.error.thread_inf_loop (dir)

engine.error.thread_inf_loop.occurred (bool)
When true, one of the threads responsible for procedural world generation is not responding. There is no safe way to kill a thread that is not responding, so when this error occurs the program must quit.

engine.error.thread_inf_loop.enable_check (bool)
When this is true, the engine will check if any worker thread has been generating a chunk for more than grace_period seconds. If so, the program will will display an error message and then exit.

engine.error.thread_inf_loop.chunk_name (string)
The name of the chunk being processed by a thread that is not responding.

engine.error.thread_inf_loop.grace_period (float)
See "engine.error.thread_inf_loop.enable_check". We recommend using 3 for this (3 seconds).

engine.memory (dir)

engine.memory.enable_memory_counter (bool)

engine.collision (dir)

engine.collision.can_shrink_to_telefrag_1 (bool)
When this is false, the system will try to prevent you from shrinking if you are too close to a moving entity.

engine.collision.telefrag_probation_duration (float)
See "game.player.collision.telefrag_probation_center".

engine.collision.can_shrink_to_telefrag_2 (bool)
When this is false, when you shrink and telefrag within the next few seconds, you will be teleported back to your last "safe position". See "game.player.collision.telefrag_probation_center".

engine.ments (dir)

engine.ments.disable_updates (bool)
When true, the engine will NOT perform any update functions on moving entities.

engine.ments.disable_loading (bool)
When true, ments are not added to a chunk (from procedural world generation) when it is being populated.

engine.ments.disable_rendering (bool)
When true, the engine will NOT render moving entities.

engine.worldgen (dir)

engine.worldgen.save_input (bool)
When this is true, the input used to generate a chunk is saved in the corresponding chunk file. See also "engine.worldgen.save_input". If use_saved_input is true, then this var save_input should be true as well.

engine.worldgen.use_saved_input (bool)
When a chunk is procedurally generated, this processes uses certain input (such as the block type of the chunk being generated. When use_saved_input is true, then 1) when we create a chunk we store the input used in a chunk file and 2) when later we recreate the same chunk, we can just use the saved input. This is useful because acquiring the input would otherwise result in a chain reaction where we need to create the entire chunk tree from the root up until the target chunk we want to generate. So in situations where we are thousands of levels deep in the chunk tree, setting use_saved_input to true is a huge speed improvement.

engine.worldgen.num_threads (int)
The number of threads used for procedural world generation. When this is zero, the main thread does all the procedural world generation. When this is n > 0, then the main thread does not do procedural world generation but instead n worker threads do the job. In the case of a fatal error in the procedural world generation code, it is better for num_threads to be zero. This var should be set before the program starts. Changing the var while the program is running will have no effect.

engine.worldgen.num_load_threads (int)
Loading a chunk consists of 3 parts: 1) procedurally generating it, 2) loading's its chunk file (if it has one), and 3) performing pre-processing so the main thread does not have to. The number of threads that do task 1) is controlled by engine.worldgen.num_threads (and this is the majority of the work). The number of threads that together do tasks 2 and 3 is controlled by this variable: engine.worldgen.num_load_threads.

engine.lua (dir)

engine.lua.chunk_gen_check_args (bool)
When this is true, whenever a Lua block script calls a C++ chunk generation API function, the C++ side will check that 1) the number of arguments is correct, 2) no argument is nil, and 3) every argument is of the correct type. End users should set this to false because it slows down chunk generation. However modders might want to set this to true to catch bugs.

engine.lua.rogue_global_watchdog (bool)
In the Lua programming language, within a function you must put the keyword "local" before a declaration otherwise it will be global. If this watchdog variable is set to true, then every so often the system will look for global Lua variables that should not exist. If it finds any, then it exits the program.

engine.lua.check_args (bool)
When this is true, whenever a Lua script calls a C++ API function, the C++ side will check that 1) the number of arguments is correct, 2) no argument is nil, and 3) every argument is of the correct type. We highly recommend setting this variable to true. If it is false, the program will hard crash if Lua calls a C++ API function incorrectly.

engine.bents (dir)

engine.bents.disable_rendering (bool)
When true, the engine will NOT render basic entities.

engine.particles (dir)

engine.particles.disable (bool)
When true, particle effects will not be rendered, and particles will not be updated.

engine.particles.min_dist (float)
Certain particle effects in the game have the "use min distance" property. These particle effects will not create particles that are within min_dist of the player.

engine.particles.sort_period (float)
Every so often, particles are sorted by their distance to the player. This var specifies how many seconds between times at which we sort.

engine.particles.throttle (dir)
Once there are too many particles in the world, whenever a new particle is requested to be created, it will only actually be created with a small probability P. Let V = "engine.particles.throttle". If the number of particles is between V.1.num and V.2.num, the probability P is V.1.frac. If the number of particles is between V.2.num and V.3.num, the probability P is V.2.frac. Finally, if the number of particles is over V.3.num, the probability P is V.3.frac.

engine.particles.throttle.3 (dir)

engine.particles.throttle.3.frac (float)

engine.particles.throttle.3.num (int)

engine.particles.throttle.1 (dir)

engine.particles.throttle.1.frac (float)

engine.particles.throttle.1.num (int)

engine.particles.throttle.2 (dir)

engine.particles.throttle.2.frac (float)

engine.particles.throttle.2.num (int)

engine.rayalg (dir)

engine.rayalg.disable (bool)
The ray algorithm is what is used when an entity is moved through the world and we need to find what it collides with. When this var is true, the engine disables this algorithm (so no collisions are detected).

engine.automatic_saving (dir)

engine.automatic_saving.chunk_threshold (int)

engine.automatic_saving.enable (bool)
If either of the vars engine.automatic_saving.enable or game.automatic_saving are true, then the game will be saved every few minutes or when there are many chunk files that need to be written to.

engine.automatic_saving.time_threshold (int)
When engine.automatic_saving.enable or game.automatic_saving is true, the game will be saved when there are at least this many chunk files that need to be written to.

engine.render (dir)

engine.render.anisotropic_filtering (bool)
When this is true, anisotropic filtering is enabled with the maximum number of allowed samples.

engine.render.enable_vsync (bool)

engine.render.max_frames_per_sec (int)
Whether or not vsync is enabled. That is, the framerate is higher when this is false.

engine.render.disable_world (bool)
When true, the engine will NOT render the world, including all entities inside the world.

engine.render.which_cycle (int)
This is needed so that we do not render the same ment during a render frame.

engine.render.level_time_rem_frac (float)
What is rendered is an interpolation between logical frames. This value specifies the interpolation value (between 0 and 1) for the current level that is being rendered.

engine.render.skip_next_frame (bool)
When this is set to true, the next frame will not be rendered. This can be used while the player is in an "explore while" loop to make it faster.

engine.render.num_render_levels (int)
How many levels are rendered. This is 5 by default.

engine.render.handle_visray_false (string)
This specifies what should happen to chunks that DO intersect the view frustum but ARE NOT render relevant. If this var is set to "cocoon_render", then the block that occupies the same space as the chunk is rendered. This looks fine and is pretty fast. This should be the typical setting, and often the chunk is a proto chunk anyway so no rendering detail is lost. If this var is set to "full_render", then the chunk is rendered fully. This is very slow. If this var is set to "no_render", then the chunk is not rendered at all (not even as a block). This looks awful, but is fast.

engine.render.dir_lighting (dir)

engine.render.dir_lighting.force_flat (bool)
This is intended for meme images and debugging. When this is true, flat shading is always used as opposed to smooth shading. This variable must be set when the program is initialized, because it is low level. Note that when force_flat is false, then whether or not flat shading is used depends on the mesh: If the mesh has normals, then smoothing shading is used, otherwise flat shading is used.

engine.render.dir_lighting.light_dir (vector)
The light direction that is used for mesh directional lighting. Light from this direction has value shade1, and the opposite side has value shade2.

engine.render.dir_lighting.shade2 (float)
This is the min lighting value used in mesh directional shading.

engine.render.dir_lighting.enable (bool)
When this is true, directional lighting is used for meshes. The normal vectors in meshes are used, but if they are missing then flat (as opposed to smooth) shading will be used instead.

engine.render.dir_lighting.shade1 (float)
This is the max lighting value used in mesh directional shading.

engine.render.rr (dir)
rr stands for "render relevant". Let X = the value of engine.render.rr.created_time. Let Y = the value of engine.render.rr.visray_hit_interval. A chunk is render relevant iff either it has been created (added to the chunk tree) within the last X seconds, or it has been hit by a visray within the last Y seconds.

engine.render.rr.visray_hit_time (float)
10.0 is a good value for this.

engine.render.rr.created_time (float)
3.0 is a good value for this.

engine.render.opengl (dir)

engine.render.opengl.no_shaders_on_typical (bool)
Consider typical rendering (no red/blue glasses mode). If this var is true, then during typical rendering no custom shaders are used (rendering uses the "fixed function pileline"). This var does not affect red/blue glasses mode, because in this mode shaders are required to render to grayscale.

engine.achievements (dir)

engine.achievements.breaker_tripped (bool)
This is set to true (for future game launches) if the game crashes during a Steam achievements update. When tripped, the game will no longer perform Steam achievements updates. This bool must be manually set to false by the user in the params.txt file to reset the circuit breaker.

engine.achievements.update (bool)
When this is true, the game will periodically tell Steam what achievements the user has locally unlocked.

engine.mods (dir)

engine.mods.list_mods_for_wrong_packages (bool)
When this is true, when selecting a mod, all packages will be listed in both the Data/Packages and Input/Packages directores. Otherwise, only those package that have a mod_for.txt file that lists package X will be displayed when the user selects mods for package X.

engine.mods.use_file_to_select_mods (bool)
When this is true, the game's mod selection GUI cannot be used. Instead, when the player plays package Data/Packages/X, the system will look for the package Input/Packages/X and in particular its dependencies.txt file to specify which mods are used.

engine.cheat (dir)

engine.cheat.enable_player_slsl_bug (bool)

engine.chunk_db (dir)

engine.chunk_db.type (string)
When you start a new game, this variable specifies which kind of chunk database is created. That is, if this var is set to "db1", then the chunk db player_save_dir/Chunks will be used (the one which uses thousands of .txt files). If this var is set to "db2", then a SQLite database will be used (in player_save_dir/Chunks2). Note: chunk db type 2 is faster than chunk db type 1. Once a new game is created, the player will continue to use that type of chunk db (unless you do something special).

engine.chunk_db.trust_manifest (bool)
The manifest is the file in the player's save folder that lists the name (and basic information) about each chunk file that is in the player's save folder. It is extremely rare, but this manifest can become corrupt if for example the user somehow kills the program in the middle of a save. If trust_manifest is false, then when we load a chunk, we ask the computer's file system if there is a chunk file for that position of the world. This can be slow on some platforms. If trust_manifest is true, then when we want to know if there is a chunk file, we simply trust the manifest on this. If you think the manifest is corrupt, simply delete it and the system will recreate it the next time you load that player's game.

engine.chunk_db.convert_up (bool)
When this is true, if you load a game that has a chunk db 1 but not a chunk db 2, then the db 1 will be copied to make a new db 2 and then the db 1 folder will be renamed (thus saving it but making it unusable).

engine.chunk_db.defrag (dir)

engine.chunk_db.defrag.num_save_period (int)
How many saves we do before we defrag the chunk database. See also "engine.chunk_db.defrag.do_periodically". We recommend 100 for this value. That is, we defrag once every 100 times that we save.

engine.chunk_db.defrag.do_periodically (bool)
When this is true, the chunk database for the current saved game will be defragged periodically. By periodically, we mean once every hour of game time or once every 100 saves (whichever comes first). Actually, this "one hour" and "100" numbers can be configured using "engine.chunk_db.defrag.time_period" and "engine.chunk_db.defrag.num_save_period".

engine.chunk_db.defrag.time_period (float)
How many seconds, in game time, pass before we defrag the chunk database. See also "engine.chunk_db.defrag.do_periodically". We recommend one hour (60 * 60 = 3600) for this value.

engine.save (dir)

engine.save.dyn_vars (dir)

engine.save.dyn_vars.num_next (int)
During a save, after num_first many dynamic variables are stored synchronously, during each subsequent frame num_next many dynamic variables are saved. This allows the player to continue playing the game why the game is being saved. We recommend a value of 5000 for this variable. If this variable is not positive, it will be set to 5000.

engine.save.dyn_vars.num_first (int)
When the game is saved, this number of dynamic variables are initially saved. We recommend a value of 20,000 for this variable. To have ALL variables saved synchronously, set this variable to -1. See also "engine.save.dyn_vars.num_next".

engine.exploration (dir)

engine.exploration.last_force_recalc (float)

engine.exploration.tethered (bool)
Normally when the user moves from one chunk to the next, all chunks on that level shift so that the following is always true: the chunk that contains the center point of the player is the central chunk for that level. However when this var is set to false, this shifting does NOT occur.

engine.exploration.disable (bool)
Exploration is the process of adding and removing chunks from the active chunk tree as the user moves through the world. When this var is true, the engine will NOT perform exploration.

engine.exploration.bait_and_switch (bool)
When true, will do all the work to create a chunk, but at the last minute (just before we populate the chunk in the chunk tree) we remove everything from the populate data except blocks).

engine.exploration.fertile_radius (dir)
The fertile radius of the viewer level is "engine.exploration.fertile_radius.0". The radius of viewer level - 1 is "engine.exploration.fertile_radius.1", etc. The default values for these are the maximum of 3 and the level radius. Also, they should all be at least 1. The fertile radius of a level specifies how far away from the viewer that chunks can contain entities other than blocks.

engine.exploration.fertile_radius.9 (int)

engine.exploration.fertile_radius.8 (int)

engine.exploration.fertile_radius.7 (int)

engine.exploration.fertile_radius.6 (int)

engine.exploration.fertile_radius.5 (int)

engine.exploration.fertile_radius.0 (int)

engine.exploration.fertile_radius.1 (int)

engine.exploration.fertile_radius.3 (int)

engine.exploration.fertile_radius.2 (int)

engine.exploration.fertile_radius.4 (int)

engine.exploration.shrink (dir)

engine.exploration.shrink.timeout_duration (float)
When there is a telefrag violation, the player cannot shirnk again until this many seconds after the current time.

engine.exploration.level_radius (dir)
The radius of the viewer level is "engine.exploration.level_radius.0". The radius of viewer level - 1 is "engine.exploration.level_radius.1", etc. The default values for these are 3,3,2,1,0,0,0,0,0...The radius of a level specifies how far away from the viewer that chunks can be created and maintained.

engine.exploration.level_radius.49 (int)

engine.exploration.level_radius.47 (int)

engine.exploration.level_radius.22 (int)

engine.exploration.level_radius.44 (int)

engine.exploration.level_radius.19 (int)

engine.exploration.level_radius.17 (int)

engine.exploration.level_radius.37 (int)

engine.exploration.level_radius.12 (int)

engine.exploration.level_radius.26 (int)

engine.exploration.level_radius.14 (int)

engine.exploration.level_radius.16 (int)

engine.exploration.level_radius.25 (int)

engine.exploration.level_radius.11 (int)

engine.exploration.level_radius.18 (int)

engine.exploration.level_radius.15 (int)

engine.exploration.level_radius.1 (int)

engine.exploration.level_radius.33 (int)

engine.exploration.level_radius.4 (int)

engine.exploration.level_radius.8 (int)

engine.exploration.level_radius.41 (int)

engine.exploration.level_radius.45 (int)

engine.exploration.level_radius.3 (int)

engine.exploration.level_radius.6 (int)

engine.exploration.level_radius.9 (int)

engine.exploration.level_radius.0 (int)

engine.exploration.level_radius.5 (int)

engine.exploration.level_radius.34 (int)

engine.exploration.level_radius.13 (int)

engine.exploration.level_radius.35 (int)

engine.exploration.level_radius.7 (int)

engine.exploration.level_radius.30 (int)

engine.exploration.level_radius.10 (int)

engine.exploration.level_radius.23 (int)

engine.exploration.level_radius.24 (int)

engine.exploration.level_radius.42 (int)

engine.exploration.level_radius.2 (int)

engine.exploration.level_radius.27 (int)

engine.exploration.level_radius.28 (int)

engine.exploration.level_radius.29 (int)

engine.exploration.level_radius.48 (int)

engine.exploration.level_radius.31 (int)

engine.exploration.level_radius.32 (int)

engine.exploration.level_radius.36 (int)

engine.exploration.level_radius.38 (int)

engine.exploration.level_radius.39 (int)

engine.exploration.level_radius.21 (int)

engine.exploration.level_radius.40 (int)

engine.exploration.level_radius.43 (int)

engine.exploration.level_radius.20 (int)

engine.exploration.level_radius.46 (int)

engine.requests (dir)

engine.requests.type (string)

engine.requests.load_game (dir)

engine.requests.load_game.hard_type (string)

engine.requests.load_game.player_name (string)

engine.requests.load_game.first_time (bool)

engine.chunks (dir)

engine.chunks.show_proto_chunks (bool)
When a chunk is first added to the chunk tree, it is an empty shell: a proto chunk. Only later is it populated. If this var is set to true, then instead of rendering a solid proto chunk normally, it is rendered using a special texture to show that it is a proto chunk.

engine.chunks.show_chunk_lines (bool)
If true, then around each chunk in the active chunk tree will be drawn a wireframe cube.

engine.visray (dir)
Every second, many visibility rays (visrays) are shot from the player's location. The purpose is to try to determine what chunks are visible from the player's position. Only chunks hit by a visray within the recent past are rendered, or updated.

engine.visray.update_interval (float)
After each time a chunk is hit by a visray, we will preform update functions for the chunk (for ments, particles, etc) for at least engine.visray.update_interval many seconds.

engine.visray.enabled (bool)
If fase, then no visrays are shot out and no system in the engine excepts visrays to hit chunks.

engine.visray.rays_per_sec (int)
The number of visrays shot from the player's position per second. Although visrays are shot in all directions, more are focused towards the direction where the player is looking.

engine.textures (dir)
Textures are loaded lazily in this program. That is, when a texture is needed, we either loaded it then and there (synchronously) or we load it asyncronously. When a texture is loaded asyncronously, then until we have the texture, we either use in place of it a black texture or a goofy pretty texture.

engine.textures.delete_time (float)
If a texture has been loaded but has not been used for this amount of time, then we delete it from memory. It can always be reloaded later if needed.

engine.textures.use_not_loaded_pretty_tex (bool)
Whether or not we should use a goofy pretty texture, instead of a black texture, while we are waiting to load a texture asyncronously.

engine.textures.async (bool)
Whether or not textures should be loaded synchronously or asyncronously.

engine.textures.pixel_load_per_frame (int)
How many pixels can be loaded synchronously in a frame before we must load the remaining textures asyncronously.

engine.cutting (dir)

engine.cutting.enabled (bool)
Currently, this engine is not doing any "cutting".

engine.surfaces (dir)

engine.surfaces.show_quad_algorithm (bool)
The "quad algorithm" is what I am calling the algorithm I invented when working on Infinifrag 2 to greedily merge surface m by n quads together for rendering a block world. When this var is true, these individual quads are shown (before a vertex buffer object for the chunk is created).

stats (dir)

stats.pending_chunks (int)
This is the total number of chunks which we have requested to populate (that have not yet been populated). Note: populating entails creating from procedural world generation code.

stats.player_speed (float)

stats.num_squares_int (int)
This is updated periodically. This is the number of "internal" squares. There are two types of squares: internal and external. An internal square is between a solid block B1 and an empty block B2 where B1 and B2 are in the chunk. An external square is where B1 is in one chunk but B2 is in a different chunk.

stats.num_rendered_quads_vbo (int)
The speed of the player, in meters per second. A block is one meter wide.

stats.num_lifetime_chunks (int)
How many chunks have been populated since the startof the program.

stats.num_chunks (int)
This is updated periodically. This is the total number of chunks in the active chunk tree.

stats.game_fps (int)
The fps the last time the game was unpaused. This is needed to determine if the world should be rendered behind the main menus.

stats.last_fps_time (float)
A helper var to compute the fps. This should probably be removed.

stats.fps (int)
The frames per second. Specifically, this is the number of frames the occurred during the last second long time period.

stats.num_blocks (int)
This is updated periodically. This is the total number of blocks in the active chunk tree. Note that in a chunk, we only store those blocks whose type are different from the default block type of that chunk.

stats.chunks_per_sec (int)
How many chunks were populated the last second.

stats.num_squares (int)
This is updated periodically. This is the total number of individual exposed 1x1 squares. These are what the player sees when they see blocks.

stats.in_dps (int)
The total damage done to the player during the last second long time period.

stats.chunks_per_sec_count (int)
A helper var to compute the chunks per sec.

stats.num_squares_ext (int)
This is updated periodically. This is the number of "external" squares. See the documendation for stats.num_squares_int

stats.last_loading_bars_time (float)
The loading bar graph shows using colors how many chunks should be removed from the chunk tree vs how many are good. This var represents the last time the loading bar graph was updated. This should probably be removed.

stats.num_rendered_quads_imm (int)
The number of quads that have been rendered in immediate mode from the last render cycle.

stats.in_dps_count (int)
A helper var to compute stats.in_dps. You have to modify this manually for the in_dps var to be useful.

stats.num_quads (int)
This is updated periodically. This is the total number of surface quads in the active chunk tree. Note that the blocks of the world are rendered using their surface quads.

stats.out_dps (int)
The total damage the player did during the last second long time period.

stats.fps_count (int)
A helper var to compute the fps. This should probably be removed.

stats.out_dps_count (int)
A helper var to compute stats.out_dps. You have to modify this manually for the out_dps var to be useful.

stats.num_particles (int)
This is updated periodically. This is the total number of particles in the active chunk tree.

stats.num_ments (int)
This is updated periodically. This is the total number of moving entities in the active chunk tree.

stats.num_cc (int)
The number of chunk changes (CC) objects. A chunk changes object stores the changes that have been made to a chunk.

stats.loading_bar_graph (dir)
These vars return the number of chunks in certain categories, sorted by level. Level 0 is the viewer's level. Level 1 is the viewer's level - 1, etc. Red means outside level radius and hit by a vis ray. Yellow means outside level radius and NOT hit by a vis ray. Green means inside level radius and hit by a vis ray. Blue means inside level radius and NOT hit by a vis ray.

stats.loading_bar_graph.9 (dir)

stats.loading_bar_graph.9.green (int)

stats.loading_bar_graph.9.red (int)

stats.loading_bar_graph.9.blue (int)

stats.loading_bar_graph.9.yellow (int)

stats.loading_bar_graph.8 (dir)

stats.loading_bar_graph.8.green (int)

stats.loading_bar_graph.8.red (int)

stats.loading_bar_graph.8.blue (int)

stats.loading_bar_graph.8.yellow (int)

stats.loading_bar_graph.7 (dir)

stats.loading_bar_graph.7.green (int)

stats.loading_bar_graph.7.red (int)

stats.loading_bar_graph.7.blue (int)

stats.loading_bar_graph.7.yellow (int)

stats.loading_bar_graph.6 (dir)

stats.loading_bar_graph.6.green (int)

stats.loading_bar_graph.6.red (int)

stats.loading_bar_graph.6.blue (int)

stats.loading_bar_graph.6.yellow (int)

stats.loading_bar_graph.5 (dir)

stats.loading_bar_graph.5.green (int)

stats.loading_bar_graph.5.red (int)

stats.loading_bar_graph.5.blue (int)

stats.loading_bar_graph.5.yellow (int)

stats.loading_bar_graph.0 (dir)

stats.loading_bar_graph.0.green (int)

stats.loading_bar_graph.0.red (int)

stats.loading_bar_graph.0.blue (int)

stats.loading_bar_graph.0.yellow (int)

stats.loading_bar_graph.1 (dir)

stats.loading_bar_graph.1.green (int)

stats.loading_bar_graph.1.red (int)

stats.loading_bar_graph.1.blue (int)

stats.loading_bar_graph.1.yellow (int)

stats.loading_bar_graph.3 (dir)

stats.loading_bar_graph.3.green (int)

stats.loading_bar_graph.3.red (int)

stats.loading_bar_graph.3.blue (int)

stats.loading_bar_graph.3.yellow (int)

stats.loading_bar_graph.2 (dir)

stats.loading_bar_graph.2.green (int)

stats.loading_bar_graph.2.red (int)

stats.loading_bar_graph.2.blue (int)

stats.loading_bar_graph.2.yellow (int)

stats.loading_bar_graph.4 (dir)

stats.loading_bar_graph.4.green (int)

stats.loading_bar_graph.4.red (int)

stats.loading_bar_graph.4.blue (int)

stats.loading_bar_graph.4.yellow (int)

home (dir)
This is a place for the user to create their own variables. This can be done with the "let" command.

home.readme (string)

console (dir)
You can open the console in game by pressing "~". These vars describe the behavior of the console. They mostly regard the look and feel of it.

console.calc_num_cols (int)
This is a read only variable. It represents the max number of characters that can be in any line of the console window. This is determined from console.num_lines (which determines the height of each line) and console.char_hw_ratio. Also, the value must be less than or equal to console.max_cols.

console.type_repeat_speed (float)
After the user holds down a key in the console for a sufficiently long amount of time, this is how many times the character is entered per second.

console.type_repeat_delay (float)
When the user holds down a key in the console, this is how long it takes before the character will be entered repeatedly.

console.char_hw_ratio (float)
The height to width ratio of any character. Note: the screen has width 1.0 and height 1.0.

console.cwd (string)
This var is not being used.

console.in (bool)
Whether or not the console is open.

console.max_cols (int)
The value of console.calc_num_cols will always be forced to be less thank or equal to console.max_cols.

console.height (float)
The fraction of the screen the console takes up when open. So a value of 1.0 means it takes up the entire screen. Note that the height of each line is console.height / console.num_lines.

console.prmt (string)
The string displayed on the left of the line that the user is currently typing into. By default this is "$ ".

console.num_lines (int)
The number of console lines displayed on the screen at any one time.

console.tilde_closes (bool)
Whether or not pressing the tilde key closes the console (when in the console).

console.messages (dir)

console.messages.showed_game_startup_warning (bool)
This is set to true once the warning message is shown that the file game_startup.lua does not exist

console.style (dir)

console.style.text_color (vector)
The (default) text color in the console window.

console.style.back_alpha (float)
The alpha of the background of the console window.

console.style.back_color (vector)
The background color of the console window.

console.style.colored_text (dir)

console.style.colored_text.basic (dir)
The most basic way to color text displayed by the console is with the basic escape sequence ^N where N is between 0 and 7 inclusive. For example, by default "^1stop" will display the word "stop" in red. Which basic escape sequences correspond to what colors can be specified here. So if console.style.colored_text.basic.1 is set to (0.0, 1.0, 0.0), then "^1stop" will display the word "stop" in green. Note that a more advanced way to use colors is with the escape sequence ^xrrggbb, a sequence of 6 hex characters (lowercase).

console.style.colored_text.basic.7 (vector)

console.style.colored_text.basic.6 (vector)

console.style.colored_text.basic.5 (vector)

console.style.colored_text.basic.0 (vector)

console.style.colored_text.basic.1 (vector)

console.style.colored_text.basic.3 (vector)

console.style.colored_text.basic.2 (vector)

console.style.colored_text.basic.4 (vector)

debug (dir)

debug.log_stack (bool)
The program maintains what is essentially a call stack. If the program exists on an error, then we print the stack to the standard output file. Indeed, every thread has its own stack. We print the stack of the thread that called our exit function. If this variable debug.log_stack, then whenever we push or pop the main thread's stack, then this will be outputted to the standard output file.

debug.charlie (bool)
Do not modify this var. This is used sometimes by the engine for debugging.

debug.bomb (bool)
Every so often, the program checks this var. If it is true, the program will exit. To exit the program immediately, use the exit command.

time (dir)

time.which_cycle (int)
Every time main loop cycle, this is incremented.

time.current (float)
The number of seconds that have elapsed since the program started.

time.elapsed (float)
The number of seconds that have elapsed since TimeSystem::UpdateTime() was called. This should be called at least 25 times per second. It can even be called hundreds of times per second.